1//! Tests for the C ABI.
2//! Those tests are passing back and forth struct and values across C ABI
3//! by combining Zig code here and its mirror in cfunc.c
4//! To run all the tests on the tier 1 architecture you can use:
5//! zig build test-c-abi -fqemu
6//! To run the tests on a specific architecture:
7//! zig test -lc main.zig cfuncs.c -target mips-linux --test-cmd qemu-mips --test-cmd-bin
8const std = @import("std");
9const builtin = @import("builtin");
10const print = std.debug.print;
11const expect = std.testing.expect;
12const expectEqual = std.testing.expectEqual;
13const have_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isArm() and
14 !builtin.cpu.arch.isMIPS() and !builtin.cpu.arch.isPowerPC32() and builtin.cpu.arch != .riscv32 and
15 builtin.cpu.arch != .hexagon and
16 builtin.cpu.arch != .s390x;
17
18const have_f128 = builtin.cpu.arch.isWasm() or (builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin() and builtin.abi != .msvc);
19const have_f80 = builtin.cpu.arch.isX86() and builtin.abi != .msvc;
20
21export fn zig_panic() noreturn {
22 @panic("zig_panic called from C");
23}
24
25extern fn run_c_tests() void;
26test run_c_tests {
27 run_c_tests();
28}
29
30extern fn c_u8(u8) void;
31extern fn c_u16(u16) void;
32extern fn c_u32(u32) void;
33extern fn c_u64(u64) void;
34extern fn c_struct_u128(U128) void;
35extern fn c_i8(i8) void;
36extern fn c_i16(i16) void;
37extern fn c_i32(i32) void;
38extern fn c_i64(i64) void;
39extern fn c_struct_i128(I128) void;
40
41// On windows x64, the first 4 are passed via registers, others on the stack.
42extern fn c_five_integers(i32, i32, i32, i32, i32) void;
43
44export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void {
45 expect(a == 12) catch @panic("test failure: zig_five_integers 12");
46 expect(b == 34) catch @panic("test failure: zig_five_integers 34");
47 expect(c == 56) catch @panic("test failure: zig_five_integers 56");
48 expect(d == 78) catch @panic("test failure: zig_five_integers 78");
49 expect(e == 90) catch @panic("test failure: zig_five_integers 90");
50}
51
52test "integers" {
53 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
54
55 c_u8(0xff);
56 c_u16(0xfffe);
57 c_u32(0xfffffffd);
58 c_u64(0xfffffffffffffffc);
59 if (have_i128) c_struct_u128(.{ .value = 0xfffffffffffffffc });
60
61 c_i8(-1);
62 c_i16(-2);
63 c_i32(-3);
64 c_i64(-4);
65 if (have_i128) c_struct_i128(.{ .value = -6 });
66 c_five_integers(12, 34, 56, 78, 90);
67}
68
69export fn zig_u8(x: u8) void {
70 expect(x == 0xff) catch @panic("test failure: zig_u8");
71}
72export fn zig_u16(x: u16) void {
73 expect(x == 0xfffe) catch @panic("test failure: zig_u16");
74}
75export fn zig_u32(x: u32) void {
76 expect(x == 0xfffffffd) catch @panic("test failure: zig_u32");
77}
78export fn zig_u64(x: u64) void {
79 expect(x == 0xfffffffffffffffc) catch @panic("test failure: zig_u64");
80}
81export fn zig_i8(x: i8) void {
82 expect(x == -1) catch @panic("test failure: zig_i8");
83}
84export fn zig_i16(x: i16) void {
85 expect(x == -2) catch @panic("test failure: zig_i16");
86}
87export fn zig_i32(x: i32) void {
88 expect(x == -3) catch @panic("test failure: zig_i32");
89}
90export fn zig_i64(x: i64) void {
91 expect(x == -4) catch @panic("test failure: zig_i64");
92}
93
94const I128 = extern struct {
95 value: i128,
96};
97const U128 = extern struct {
98 value: u128,
99};
100export fn zig_struct_i128(a: I128) void {
101 expect(a.value == -6) catch @panic("test failure: zig_struct_i128");
102}
103export fn zig_struct_u128(a: U128) void {
104 expect(a.value == 0xfffffffffffffffc) catch @panic("test failure: zig_struct_u128");
105}
106
107// On windows x64, the first 4 are passed via registers, others on the stack.
108extern fn c_five_floats(f32, f32, f32, f32, f32) void;
109
110export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {
111 expect(a == 1.0) catch @panic("test failure: zig_five_floats 1.0");
112 expect(b == 2.0) catch @panic("test failure: zig_five_floats 2.0");
113 expect(c == 3.0) catch @panic("test failure: zig_five_floats 3.0");
114 expect(d == 4.0) catch @panic("test failure: zig_five_floats 4.0");
115 expect(e == 5.0) catch @panic("test failure: zig_five_floats 5.0");
116}
117
118test "floats" {
119 c_five_floats(1.0, 2.0, 3.0, 4.0, 5.0);
120}
121
122extern fn c_ptr(*anyopaque) void;
123
124test "pointer" {
125 c_ptr(@as(*anyopaque, @ptrFromInt(0xdeadbeef)));
126}
127
128export fn zig_ptr(x: *anyopaque) void {
129 expect(@intFromPtr(x) == 0xdeadbeef) catch @panic("test failure: zig_ptr");
130}
131
132extern fn c_bool(bool) void;
133
134test "bool" {
135 c_bool(true);
136}
137
138export fn zig_bool(x: bool) void {
139 expect(x) catch @panic("test failure: zig_bool");
140}
141
142// TODO: Replace these with the correct types once we resolve
143// https://github.com/ziglang/zig/issues/8465
144//
145// For now, we have no way of referring to the _Complex C types from Zig,
146// so our ABI is unavoidably broken on some platforms (such as x86)
147const ComplexFloat = extern struct {
148 real: f32,
149 imag: f32,
150};
151const ComplexDouble = extern struct {
152 real: f64,
153 imag: f64,
154};
155
156// Note: These two functions match the signature of __mulsc3 and __muldc3 in compiler-rt (and libgcc)
157extern fn c_cmultf_comp(a_r: f32, a_i: f32, b_r: f32, b_i: f32) ComplexFloat;
158extern fn c_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble;
159
160extern fn c_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat;
161extern fn c_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble;
162
163const complex_abi_compatible = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isMIPS() and
164 !builtin.cpu.arch.isArm() and !builtin.cpu.arch.isPowerPC() and !builtin.cpu.arch.isRISCV() and
165 builtin.cpu.arch != .hexagon and
166 builtin.cpu.arch != .s390x and
167 !(builtin.cpu.arch.isLoongArch() and builtin.abi.float() == .soft);
168
169test "complex float" {
170 if (!complex_abi_compatible) return error.SkipZigTest;
171
172 const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
173 const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
174
175 const z = c_cmultf(a, b);
176 try expect(z.real == 1.5);
177 try expect(z.imag == 13.5);
178}
179
180test "complex float by component" {
181 if (!complex_abi_compatible) return error.SkipZigTest;
182
183 const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
184 const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
185
186 const z2 = c_cmultf_comp(a.real, a.imag, b.real, b.imag);
187 try expect(z2.real == 1.5);
188 try expect(z2.imag == 13.5);
189}
190
191test "complex double" {
192 if (!complex_abi_compatible) return error.SkipZigTest;
193
194 const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
195 const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
196
197 const z = c_cmultd(a, b);
198 try expect(z.real == 1.5);
199 try expect(z.imag == 13.5);
200}
201
202test "complex double by component" {
203 if (!complex_abi_compatible) return error.SkipZigTest;
204
205 const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
206 const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
207
208 const z = c_cmultd_comp(a.real, a.imag, b.real, b.imag);
209 try expect(z.real == 1.5);
210 try expect(z.imag == 13.5);
211}
212
213export fn zig_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat {
214 expect(a.real == 1.25) catch @panic("test failure: zig_cmultf 1");
215 expect(a.imag == 2.6) catch @panic("test failure: zig_cmultf 2");
216 expect(b.real == 11.3) catch @panic("test failure: zig_cmultf 3");
217 expect(b.imag == -1.5) catch @panic("test failure: zig_cmultf 4");
218
219 return .{ .real = 1.5, .imag = 13.5 };
220}
221
222export fn zig_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble {
223 expect(a.real == 1.25) catch @panic("test failure: zig_cmultd 1");
224 expect(a.imag == 2.6) catch @panic("test failure: zig_cmultd 2");
225 expect(b.real == 11.3) catch @panic("test failure: zig_cmultd 3");
226 expect(b.imag == -1.5) catch @panic("test failure: zig_cmultd 4");
227
228 return .{ .real = 1.5, .imag = 13.5 };
229}
230
231export fn zig_cmultf_comp(a_r: f32, a_i: f32, b_r: f32, b_i: f32) ComplexFloat {
232 expect(a_r == 1.25) catch @panic("test failure: zig_cmultf_comp 1");
233 expect(a_i == 2.6) catch @panic("test failure: zig_cmultf_comp 2");
234 expect(b_r == 11.3) catch @panic("test failure: zig_cmultf_comp 3");
235 expect(b_i == -1.5) catch @panic("test failure: zig_cmultf_comp 4");
236
237 return .{ .real = 1.5, .imag = 13.5 };
238}
239
240export fn zig_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble {
241 expect(a_r == 1.25) catch @panic("test failure: zig_cmultd_comp 1");
242 expect(a_i == 2.6) catch @panic("test failure: zig_cmultd_comp 2");
243 expect(b_r == 11.3) catch @panic("test failure: zig_cmultd_comp 3");
244 expect(b_i == -1.5) catch @panic("test failure: zig_cmultd_comp 4");
245
246 return .{ .real = 1.5, .imag = 13.5 };
247}
248
249export fn zig_ret_f32() f32 {
250 return 1;
251}
252export fn zig_f32(f: f32, i: usize) void {
253 expect(f == 2) catch @panic("test failure");
254 expect(i == 1) catch @panic("test failure");
255}
256export fn zig_1_f32(_: usize, f: f32, i: usize) void {
257 expect(f == 3) catch @panic("test failure");
258 expect(i == 2) catch @panic("test failure");
259}
260export fn zig_2_f32(_: usize, _: usize, f: f32, i: usize) void {
261 expect(f == 4) catch @panic("test failure");
262 expect(i == 3) catch @panic("test failure");
263}
264export fn zig_3_f32(_: usize, _: usize, _: usize, f: f32, i: usize) void {
265 expect(f == 5) catch @panic("test failure");
266 expect(i == 4) catch @panic("test failure");
267}
268export fn zig_4_f32(_: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
269 expect(f == 6) catch @panic("test failure");
270 expect(i == 5) catch @panic("test failure");
271}
272export fn zig_5_f32(_: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
273 expect(f == 7) catch @panic("test failure");
274 expect(i == 6) catch @panic("test failure");
275}
276export fn zig_6_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
277 expect(f == 8) catch @panic("test failure");
278 expect(i == 7) catch @panic("test failure");
279}
280export fn zig_7_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
281 expect(f == 9) catch @panic("test failure");
282 expect(i == 8) catch @panic("test failure");
283}
284export fn zig_8_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
285 expect(f == 10) catch @panic("test failure");
286 expect(i == 9) catch @panic("test failure");
287}
288
289extern fn c_ret_f32() f32;
290extern fn c_f32(f32, usize) void;
291extern fn c_1_f32(usize, f32, usize) void;
292extern fn c_2_f32(usize, usize, f32, usize) void;
293extern fn c_3_f32(usize, usize, usize, f32, usize) void;
294extern fn c_4_f32(usize, usize, usize, usize, f32, usize) void;
295extern fn c_5_f32(usize, usize, usize, usize, usize, f32, usize) void;
296extern fn c_6_f32(usize, usize, usize, usize, usize, usize, f32, usize) void;
297extern fn c_7_f32(usize, usize, usize, usize, usize, usize, usize, f32, usize) void;
298extern fn c_8_f32(usize, usize, usize, usize, usize, usize, usize, usize, f32, usize) void;
299extern fn c_test_f32() void;
300
301test "f32" {
302 const f = c_ret_f32();
303 try expect(f == 11);
304 c_f32(12, 1);
305 c_1_f32(0, 13, 2);
306 c_2_f32(0, 1, 14, 3);
307 c_3_f32(0, 1, 2, 15, 4);
308 c_4_f32(0, 1, 2, 3, 16, 5);
309 c_5_f32(0, 1, 2, 3, 4, 17, 6);
310 c_6_f32(0, 1, 2, 3, 4, 5, 18, 7);
311 c_7_f32(0, 1, 2, 3, 4, 5, 6, 19, 8);
312 c_8_f32(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
313 c_test_f32();
314}
315
316export fn zig_ret_f64() f64 {
317 return 1;
318}
319export fn zig_f64(f: f64, i: usize) void {
320 expect(f == 2) catch @panic("test failure");
321 expect(i == 1) catch @panic("test failure");
322}
323export fn zig_1_f64(_: usize, f: f64, i: usize) void {
324 expect(f == 3) catch @panic("test failure");
325 expect(i == 2) catch @panic("test failure");
326}
327export fn zig_2_f64(_: usize, _: usize, f: f64, i: usize) void {
328 expect(f == 4) catch @panic("test failure");
329 expect(i == 3) catch @panic("test failure");
330}
331export fn zig_3_f64(_: usize, _: usize, _: usize, f: f64, i: usize) void {
332 expect(f == 5) catch @panic("test failure");
333 expect(i == 4) catch @panic("test failure");
334}
335export fn zig_4_f64(_: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
336 expect(f == 6) catch @panic("test failure");
337 expect(i == 5) catch @panic("test failure");
338}
339export fn zig_5_f64(_: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
340 expect(f == 7) catch @panic("test failure");
341 expect(i == 6) catch @panic("test failure");
342}
343export fn zig_6_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
344 expect(f == 8) catch @panic("test failure");
345 expect(i == 7) catch @panic("test failure");
346}
347export fn zig_7_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
348 expect(f == 9) catch @panic("test failure");
349 expect(i == 8) catch @panic("test failure");
350}
351export fn zig_8_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
352 expect(f == 10) catch @panic("test failure");
353 expect(i == 9) catch @panic("test failure");
354}
355
356extern fn c_ret_f64() f64;
357extern fn c_f64(f64, usize) void;
358extern fn c_1_f64(usize, f64, usize) void;
359extern fn c_2_f64(usize, usize, f64, usize) void;
360extern fn c_3_f64(usize, usize, usize, f64, usize) void;
361extern fn c_4_f64(usize, usize, usize, usize, f64, usize) void;
362extern fn c_5_f64(usize, usize, usize, usize, usize, f64, usize) void;
363extern fn c_6_f64(usize, usize, usize, usize, usize, usize, f64, usize) void;
364extern fn c_7_f64(usize, usize, usize, usize, usize, usize, usize, f64, usize) void;
365extern fn c_8_f64(usize, usize, usize, usize, usize, usize, usize, usize, f64, usize) void;
366extern fn c_test_f64() void;
367
368test "f64" {
369 const f = c_ret_f64();
370 try expect(f == 11);
371 c_f64(12, 1);
372 c_1_f64(0, 13, 2);
373 c_2_f64(0, 1, 14, 3);
374 c_3_f64(0, 1, 2, 15, 4);
375 c_4_f64(0, 1, 2, 3, 16, 5);
376 c_5_f64(0, 1, 2, 3, 4, 17, 6);
377 c_6_f64(0, 1, 2, 3, 4, 5, 18, 7);
378 c_7_f64(0, 1, 2, 3, 4, 5, 6, 19, 8);
379 c_8_f64(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
380 c_test_f64();
381}
382
383export fn zig_ret_longdouble() c_longdouble {
384 return 1;
385}
386export fn zig_longdouble(f: c_longdouble, i: usize) void {
387 expect(f == 2) catch @panic("test failure");
388 expect(i == 1) catch @panic("test failure");
389}
390export fn zig_1_longdouble(_: usize, f: c_longdouble, i: usize) void {
391 expect(f == 3) catch @panic("test failure");
392 expect(i == 2) catch @panic("test failure");
393}
394export fn zig_2_longdouble(_: usize, _: usize, f: c_longdouble, i: usize) void {
395 expect(f == 4) catch @panic("test failure");
396 expect(i == 3) catch @panic("test failure");
397}
398export fn zig_3_longdouble(_: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
399 expect(f == 5) catch @panic("test failure");
400 expect(i == 4) catch @panic("test failure");
401}
402export fn zig_4_longdouble(_: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
403 expect(f == 6) catch @panic("test failure");
404 expect(i == 5) catch @panic("test failure");
405}
406export fn zig_5_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
407 expect(f == 7) catch @panic("test failure");
408 expect(i == 6) catch @panic("test failure");
409}
410export fn zig_6_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
411 expect(f == 8) catch @panic("test failure");
412 expect(i == 7) catch @panic("test failure");
413}
414export fn zig_7_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
415 expect(f == 9) catch @panic("test failure");
416 expect(i == 8) catch @panic("test failure");
417}
418export fn zig_8_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
419 expect(f == 10) catch @panic("test failure");
420 expect(i == 9) catch @panic("test failure");
421}
422
423extern fn c_ret_longdouble() c_longdouble;
424extern fn @"c_longdouble"(c_longdouble, usize) void;
425extern fn c_1_longdouble(usize, c_longdouble, usize) void;
426extern fn c_2_longdouble(usize, usize, c_longdouble, usize) void;
427extern fn c_3_longdouble(usize, usize, usize, c_longdouble, usize) void;
428extern fn c_4_longdouble(usize, usize, usize, usize, c_longdouble, usize) void;
429extern fn c_5_longdouble(usize, usize, usize, usize, usize, c_longdouble, usize) void;
430extern fn c_6_longdouble(usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
431extern fn c_7_longdouble(usize, usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
432extern fn c_8_longdouble(usize, usize, usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
433extern fn c_test_longdouble() void;
434
435test "long double" {
436 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
437
438 const f = c_ret_longdouble();
439 try expect(f == 11);
440 @"c_longdouble"(12, 1);
441 c_1_longdouble(0, 13, 2);
442 c_2_longdouble(0, 1, 14, 3);
443 c_3_longdouble(0, 1, 2, 15, 4);
444 c_4_longdouble(0, 1, 2, 3, 16, 5);
445 c_5_longdouble(0, 1, 2, 3, 4, 17, 6);
446 c_6_longdouble(0, 1, 2, 3, 4, 5, 18, 7);
447 c_7_longdouble(0, 1, 2, 3, 4, 5, 6, 19, 8);
448 c_8_longdouble(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
449 c_test_longdouble();
450}
451
452comptime {
453 skip: {
454 if (builtin.zig_backend == .stage2_wasm) break :skip;
455 if (builtin.cpu.arch == .hexagon) break :skip;
456 if (builtin.cpu.arch == .loongarch64) break :skip;
457 if (builtin.cpu.arch.isMIPS()) break :skip;
458 if (builtin.cpu.arch.isPowerPC64()) break :skip;
459 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
460
461 _ = struct {
462 export fn zig_ret_vector_2_bool() @Vector(2, bool) {
463 return .{
464 false,
465 false,
466 };
467 }
468 export fn zig_vector_2_bool(vec: @Vector(2, bool)) void {
469 expect(vec[0] == false) catch @panic("test failure");
470 expect(vec[1] == true) catch @panic("test failure");
471 }
472 };
473 }
474}
475
476extern fn c_ret_vector_2_bool() @Vector(2, bool);
477extern fn c_vector_2_bool(@Vector(2, bool)) void;
478extern fn c_test_vector_2_bool() void;
479
480test "@Vector(2, bool)" {
481 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
482 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
483 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
484 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
485 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
486 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
487 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
488 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
489
490 const vec = c_ret_vector_2_bool();
491 try expect(vec[0] == true);
492 try expect(vec[1] == false);
493 c_vector_2_bool(.{
494 true,
495 true,
496 });
497 c_test_vector_2_bool();
498}
499
500comptime {
501 skip: {
502 if (builtin.zig_backend == .stage2_wasm) break :skip;
503 if (builtin.cpu.arch == .hexagon) break :skip;
504 if (builtin.cpu.arch == .loongarch64) break :skip;
505 if (builtin.cpu.arch.isMIPS()) break :skip;
506 if (builtin.cpu.arch.isPowerPC64()) break :skip;
507 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
508
509 _ = struct {
510 export fn zig_ret_vector_4_bool() @Vector(4, bool) {
511 return .{
512 false,
513 true,
514 true,
515 true,
516 };
517 }
518 export fn zig_vector_4_bool(vec: @Vector(4, bool)) void {
519 expect(vec[0] == false) catch @panic("test failure");
520 expect(vec[1] == false) catch @panic("test failure");
521 expect(vec[2] == false) catch @panic("test failure");
522 expect(vec[3] == false) catch @panic("test failure");
523 }
524 };
525 }
526}
527
528extern fn c_ret_vector_4_bool() @Vector(4, bool);
529extern fn c_vector_4_bool(@Vector(4, bool)) void;
530extern fn c_test_vector_4_bool() void;
531
532test "@Vector(4, bool)" {
533 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
534 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
535 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
536 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
537 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
538 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
539 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
540 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
541
542 const vec = c_ret_vector_4_bool();
543 try expect(vec[0] == true);
544 try expect(vec[1] == false);
545 try expect(vec[2] == true);
546 try expect(vec[3] == false);
547 c_vector_4_bool(.{
548 true,
549 true,
550 false,
551 true,
552 });
553 c_test_vector_4_bool();
554}
555
556comptime {
557 skip: {
558 if (builtin.zig_backend == .stage2_wasm) break :skip;
559 if (builtin.cpu.arch == .hexagon) break :skip;
560 if (builtin.cpu.arch == .loongarch64) break :skip;
561 if (builtin.cpu.arch.isMIPS()) break :skip;
562 if (builtin.cpu.arch.isPowerPC64()) break :skip;
563 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
564
565 _ = struct {
566 export fn zig_ret_vector_8_bool() @Vector(8, bool) {
567 return .{
568 false,
569 false,
570 false,
571 false,
572 true,
573 false,
574 false,
575 false,
576 };
577 }
578 export fn zig_vector_8_bool(vec: @Vector(8, bool)) void {
579 expect(vec[0] == true) catch @panic("test failure");
580 expect(vec[1] == true) catch @panic("test failure");
581 expect(vec[2] == false) catch @panic("test failure");
582 expect(vec[3] == true) catch @panic("test failure");
583 expect(vec[4] == false) catch @panic("test failure");
584 expect(vec[5] == true) catch @panic("test failure");
585 expect(vec[6] == true) catch @panic("test failure");
586 expect(vec[7] == false) catch @panic("test failure");
587 }
588 };
589 }
590}
591
592extern fn c_ret_vector_8_bool() @Vector(8, bool);
593extern fn c_vector_8_bool(@Vector(8, bool)) void;
594extern fn c_test_vector_8_bool() void;
595
596test "@Vector(8, bool)" {
597 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
598 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
599 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
600 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
601 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
602 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
603 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
604 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
605
606 const vec = c_ret_vector_8_bool();
607 try expect(vec[0] == false);
608 try expect(vec[1] == true);
609 try expect(vec[2] == false);
610 try expect(vec[3] == false);
611 try expect(vec[4] == true);
612 try expect(vec[5] == false);
613 try expect(vec[6] == false);
614 try expect(vec[7] == true);
615 c_vector_8_bool(.{
616 true,
617 false,
618 true,
619 true,
620 true,
621 true,
622 false,
623 true,
624 });
625 c_test_vector_8_bool();
626}
627
628comptime {
629 skip: {
630 if (builtin.zig_backend == .stage2_wasm) break :skip;
631 if (builtin.cpu.arch == .hexagon) break :skip;
632 if (builtin.cpu.arch == .loongarch64) break :skip;
633 if (builtin.cpu.arch.isMIPS()) break :skip;
634 if (builtin.cpu.arch.isPowerPC64()) break :skip;
635 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
636
637 _ = struct {
638 export fn zig_ret_vector_16_bool() @Vector(16, bool) {
639 return .{
640 false,
641 true,
642 false,
643 false,
644 false,
645 true,
646 false,
647 false,
648 true,
649 false,
650 false,
651 false,
652 false,
653 true,
654 false,
655 false,
656 };
657 }
658 export fn zig_vector_16_bool(vec: @Vector(16, bool)) void {
659 expect(vec[0] == true) catch @panic("test failure");
660 expect(vec[1] == false) catch @panic("test failure");
661 expect(vec[2] == true) catch @panic("test failure");
662 expect(vec[3] == true) catch @panic("test failure");
663 expect(vec[4] == true) catch @panic("test failure");
664 expect(vec[5] == false) catch @panic("test failure");
665 expect(vec[6] == false) catch @panic("test failure");
666 expect(vec[7] == false) catch @panic("test failure");
667 expect(vec[8] == true) catch @panic("test failure");
668 expect(vec[9] == true) catch @panic("test failure");
669 expect(vec[10] == true) catch @panic("test failure");
670 expect(vec[11] == true) catch @panic("test failure");
671 expect(vec[12] == false) catch @panic("test failure");
672 expect(vec[13] == false) catch @panic("test failure");
673 expect(vec[14] == false) catch @panic("test failure");
674 expect(vec[15] == true) catch @panic("test failure");
675 }
676 };
677 }
678}
679
680extern fn c_ret_vector_16_bool() @Vector(16, bool);
681extern fn c_vector_16_bool(@Vector(16, bool)) void;
682extern fn c_test_vector_16_bool() void;
683
684test "@Vector(16, bool)" {
685 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
686 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
687 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
688 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
689 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
690 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
691 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
692 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
693
694 const vec = c_ret_vector_16_bool();
695 try expect(vec[0] == true);
696 try expect(vec[1] == true);
697 try expect(vec[2] == false);
698 try expect(vec[3] == false);
699 try expect(vec[4] == false);
700 try expect(vec[5] == false);
701 try expect(vec[6] == true);
702 try expect(vec[7] == false);
703 try expect(vec[8] == true);
704 try expect(vec[9] == false);
705 try expect(vec[10] == false);
706 try expect(vec[11] == true);
707 try expect(vec[12] == true);
708 try expect(vec[13] == false);
709 try expect(vec[14] == true);
710 try expect(vec[15] == true);
711 c_vector_16_bool(.{
712 true,
713 false,
714 false,
715 false,
716 true,
717 false,
718 true,
719 true,
720 true,
721 true,
722 true,
723 true,
724 false,
725 false,
726 false,
727 false,
728 });
729 c_test_vector_16_bool();
730}
731
732comptime {
733 skip: {
734 if (builtin.zig_backend == .stage2_wasm) break :skip;
735 if (builtin.cpu.arch == .hexagon) break :skip;
736 if (builtin.cpu.arch == .loongarch64) break :skip;
737 if (builtin.cpu.arch.isMIPS()) break :skip;
738 if (builtin.cpu.arch.isPowerPC64()) break :skip;
739 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
740
741 _ = struct {
742 export fn zig_ret_vector_32_bool() @Vector(32, bool) {
743 return .{
744 false,
745 true,
746 false,
747 false,
748 true,
749 false,
750 true,
751 true,
752 true,
753 true,
754 true,
755 true,
756 false,
757 false,
758 false,
759 false,
760 false,
761 false,
762 true,
763 true,
764 true,
765 false,
766 true,
767 false,
768 true,
769 false,
770 false,
771 true,
772 false,
773 false,
774 true,
775 true,
776 };
777 }
778 export fn zig_vector_32_bool(vec: @Vector(32, bool)) void {
779 expect(vec[0] == false) catch @panic("test failure");
780 expect(vec[1] == false) catch @panic("test failure");
781 expect(vec[2] == false) catch @panic("test failure");
782 expect(vec[3] == true) catch @panic("test failure");
783 expect(vec[4] == true) catch @panic("test failure");
784 expect(vec[5] == false) catch @panic("test failure");
785 expect(vec[6] == false) catch @panic("test failure");
786 expect(vec[7] == true) catch @panic("test failure");
787 expect(vec[8] == false) catch @panic("test failure");
788 expect(vec[9] == true) catch @panic("test failure");
789 expect(vec[10] == true) catch @panic("test failure");
790 expect(vec[11] == true) catch @panic("test failure");
791 expect(vec[12] == false) catch @panic("test failure");
792 expect(vec[13] == false) catch @panic("test failure");
793 expect(vec[14] == true) catch @panic("test failure");
794 expect(vec[15] == true) catch @panic("test failure");
795 expect(vec[16] == true) catch @panic("test failure");
796 expect(vec[17] == true) catch @panic("test failure");
797 expect(vec[18] == true) catch @panic("test failure");
798 expect(vec[19] == false) catch @panic("test failure");
799 expect(vec[20] == true) catch @panic("test failure");
800 expect(vec[21] == true) catch @panic("test failure");
801 expect(vec[22] == true) catch @panic("test failure");
802 expect(vec[23] == false) catch @panic("test failure");
803 expect(vec[24] == false) catch @panic("test failure");
804 expect(vec[25] == true) catch @panic("test failure");
805 expect(vec[26] == true) catch @panic("test failure");
806 expect(vec[27] == false) catch @panic("test failure");
807 expect(vec[28] == true) catch @panic("test failure");
808 expect(vec[29] == true) catch @panic("test failure");
809 expect(vec[30] == false) catch @panic("test failure");
810 expect(vec[31] == true) catch @panic("test failure");
811 }
812 };
813 }
814}
815
816extern fn c_ret_vector_32_bool() @Vector(32, bool);
817extern fn c_vector_32_bool(@Vector(32, bool)) void;
818extern fn c_test_vector_32_bool() void;
819
820test "@Vector(32, bool)" {
821 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
822 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
823 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
824 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
825 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
826 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
827 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
828 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
829
830 const vec = c_ret_vector_32_bool();
831 try expect(vec[0] == true);
832 try expect(vec[1] == false);
833 try expect(vec[2] == true);
834 try expect(vec[3] == true);
835 try expect(vec[4] == true);
836 try expect(vec[5] == false);
837 try expect(vec[6] == true);
838 try expect(vec[7] == false);
839 try expect(vec[8] == true);
840 try expect(vec[9] == true);
841 try expect(vec[10] == true);
842 try expect(vec[11] == false);
843 try expect(vec[12] == true);
844 try expect(vec[13] == true);
845 try expect(vec[14] == false);
846 try expect(vec[15] == false);
847 try expect(vec[16] == true);
848 try expect(vec[17] == false);
849 try expect(vec[18] == false);
850 try expect(vec[19] == false);
851 try expect(vec[20] == false);
852 try expect(vec[21] == true);
853 try expect(vec[22] == true);
854 try expect(vec[23] == true);
855 try expect(vec[24] == false);
856 try expect(vec[25] == true);
857 try expect(vec[26] == false);
858 try expect(vec[27] == false);
859 try expect(vec[28] == true);
860 try expect(vec[29] == false);
861 try expect(vec[30] == false);
862 try expect(vec[31] == false);
863 c_vector_32_bool(.{
864 true,
865 false,
866 true,
867 true,
868 false,
869 false,
870 true,
871 false,
872 true,
873 false,
874 true,
875 true,
876 true,
877 false,
878 false,
879 true,
880 false,
881 true,
882 false,
883 true,
884 true,
885 true,
886 true,
887 true,
888 false,
889 true,
890 true,
891 true,
892 false,
893 true,
894 true,
895 false,
896 });
897 c_test_vector_32_bool();
898}
899
900comptime {
901 skip: {
902 if (builtin.zig_backend == .stage2_wasm) break :skip;
903 if (builtin.cpu.arch == .hexagon) break :skip;
904 if (builtin.cpu.arch == .loongarch64) break :skip;
905 if (builtin.cpu.arch.isMIPS()) break :skip;
906 if (builtin.cpu.arch.isPowerPC64()) break :skip;
907 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
908
909 _ = struct {
910 export fn zig_ret_vector_64_bool() @Vector(64, bool) {
911 return .{
912 true,
913 false,
914 true,
915 false,
916 false,
917 true,
918 false,
919 true,
920 true,
921 false,
922 true,
923 false,
924 true,
925 false,
926 false,
927 true,
928 false,
929 false,
930 true,
931 true,
932 false,
933 false,
934 true,
935 false,
936 false,
937 true,
938 true,
939 true,
940 true,
941 true,
942 false,
943 false,
944 true,
945 true,
946 true,
947 true,
948 false,
949 true,
950 false,
951 true,
952 true,
953 true,
954 true,
955 true,
956 false,
957 false,
958 false,
959 true,
960 true,
961 true,
962 false,
963 true,
964 true,
965 true,
966 false,
967 false,
968 false,
969 true,
970 false,
971 false,
972 true,
973 false,
974 true,
975 false,
976 };
977 }
978 export fn zig_vector_64_bool(vec: @Vector(64, bool)) void {
979 expect(vec[0] == true) catch @panic("test failure");
980 expect(vec[1] == true) catch @panic("test failure");
981 expect(vec[2] == false) catch @panic("test failure");
982 expect(vec[3] == true) catch @panic("test failure");
983 expect(vec[4] == false) catch @panic("test failure");
984 expect(vec[5] == true) catch @panic("test failure");
985 expect(vec[6] == false) catch @panic("test failure");
986 expect(vec[7] == false) catch @panic("test failure");
987 expect(vec[8] == true) catch @panic("test failure");
988 expect(vec[9] == true) catch @panic("test failure");
989 expect(vec[10] == true) catch @panic("test failure");
990 expect(vec[11] == true) catch @panic("test failure");
991 expect(vec[12] == true) catch @panic("test failure");
992 expect(vec[13] == true) catch @panic("test failure");
993 expect(vec[14] == true) catch @panic("test failure");
994 expect(vec[15] == false) catch @panic("test failure");
995 expect(vec[16] == false) catch @panic("test failure");
996 expect(vec[17] == true) catch @panic("test failure");
997 expect(vec[18] == true) catch @panic("test failure");
998 expect(vec[19] == false) catch @panic("test failure");
999 expect(vec[20] == true) catch @panic("test failure");
1000 expect(vec[21] == true) catch @panic("test failure");
1001 expect(vec[22] == true) catch @panic("test failure");
1002 expect(vec[23] == true) catch @panic("test failure");
1003 expect(vec[24] == false) catch @panic("test failure");
1004 expect(vec[25] == false) catch @panic("test failure");
1005 expect(vec[26] == true) catch @panic("test failure");
1006 expect(vec[27] == false) catch @panic("test failure");
1007 expect(vec[28] == false) catch @panic("test failure");
1008 expect(vec[29] == true) catch @panic("test failure");
1009 expect(vec[30] == false) catch @panic("test failure");
1010 expect(vec[31] == true) catch @panic("test failure");
1011 expect(vec[32] == false) catch @panic("test failure");
1012 expect(vec[33] == true) catch @panic("test failure");
1013 expect(vec[34] == true) catch @panic("test failure");
1014 expect(vec[35] == false) catch @panic("test failure");
1015 expect(vec[36] == true) catch @panic("test failure");
1016 expect(vec[37] == true) catch @panic("test failure");
1017 expect(vec[38] == false) catch @panic("test failure");
1018 expect(vec[39] == false) catch @panic("test failure");
1019 expect(vec[40] == true) catch @panic("test failure");
1020 expect(vec[41] == true) catch @panic("test failure");
1021 expect(vec[42] == true) catch @panic("test failure");
1022 expect(vec[43] == true) catch @panic("test failure");
1023 expect(vec[44] == true) catch @panic("test failure");
1024 expect(vec[45] == false) catch @panic("test failure");
1025 expect(vec[46] == true) catch @panic("test failure");
1026 expect(vec[47] == false) catch @panic("test failure");
1027 expect(vec[48] == false) catch @panic("test failure");
1028 expect(vec[49] == false) catch @panic("test failure");
1029 expect(vec[50] == false) catch @panic("test failure");
1030 expect(vec[51] == false) catch @panic("test failure");
1031 expect(vec[52] == true) catch @panic("test failure");
1032 expect(vec[53] == false) catch @panic("test failure");
1033 expect(vec[54] == false) catch @panic("test failure");
1034 expect(vec[55] == true) catch @panic("test failure");
1035 expect(vec[56] == true) catch @panic("test failure");
1036 expect(vec[57] == false) catch @panic("test failure");
1037 expect(vec[58] == false) catch @panic("test failure");
1038 expect(vec[59] == false) catch @panic("test failure");
1039 expect(vec[60] == true) catch @panic("test failure");
1040 expect(vec[61] == true) catch @panic("test failure");
1041 expect(vec[62] == true) catch @panic("test failure");
1042 expect(vec[63] == true) catch @panic("test failure");
1043 }
1044 };
1045 }
1046}
1047
1048extern fn c_ret_vector_64_bool() @Vector(64, bool);
1049extern fn c_vector_64_bool(@Vector(64, bool)) void;
1050extern fn c_test_vector_64_bool() void;
1051
1052test "@Vector(64, bool)" {
1053 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1054 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1055 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
1056 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
1057 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1058 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
1059
1060 const vec = c_ret_vector_64_bool();
1061 try expect(vec[0] == false);
1062 try expect(vec[1] == true);
1063 try expect(vec[2] == false);
1064 try expect(vec[3] == true);
1065 try expect(vec[4] == true);
1066 try expect(vec[5] == true);
1067 try expect(vec[6] == false);
1068 try expect(vec[7] == true);
1069 try expect(vec[8] == true);
1070 try expect(vec[9] == true);
1071 try expect(vec[10] == true);
1072 try expect(vec[11] == true);
1073 try expect(vec[12] == true);
1074 try expect(vec[13] == false);
1075 try expect(vec[14] == true);
1076 try expect(vec[15] == true);
1077 try expect(vec[16] == true);
1078 try expect(vec[17] == false);
1079 try expect(vec[18] == false);
1080 try expect(vec[19] == false);
1081 try expect(vec[20] == true);
1082 try expect(vec[21] == true);
1083 try expect(vec[22] == false);
1084 try expect(vec[23] == true);
1085 try expect(vec[24] == false);
1086 try expect(vec[25] == true);
1087 try expect(vec[26] == false);
1088 try expect(vec[27] == true);
1089 try expect(vec[28] == false);
1090 try expect(vec[29] == true);
1091 try expect(vec[30] == false);
1092 try expect(vec[31] == true);
1093 try expect(vec[32] == false);
1094 try expect(vec[33] == false);
1095 try expect(vec[34] == true);
1096 try expect(vec[35] == true);
1097 try expect(vec[36] == false);
1098 try expect(vec[37] == false);
1099 try expect(vec[38] == false);
1100 try expect(vec[39] == true);
1101 try expect(vec[40] == true);
1102 try expect(vec[41] == true);
1103 try expect(vec[42] == true);
1104 try expect(vec[43] == false);
1105 try expect(vec[44] == false);
1106 try expect(vec[45] == false);
1107 try expect(vec[46] == true);
1108 try expect(vec[47] == true);
1109 try expect(vec[48] == false);
1110 try expect(vec[49] == false);
1111 try expect(vec[50] == true);
1112 try expect(vec[51] == false);
1113 try expect(vec[52] == false);
1114 try expect(vec[53] == false);
1115 try expect(vec[54] == false);
1116 try expect(vec[55] == true);
1117 try expect(vec[56] == false);
1118 try expect(vec[57] == false);
1119 try expect(vec[58] == false);
1120 try expect(vec[59] == true);
1121 try expect(vec[60] == true);
1122 try expect(vec[61] == true);
1123 try expect(vec[62] == true);
1124 try expect(vec[63] == true);
1125 c_vector_64_bool(.{
1126 true,
1127 true,
1128 true,
1129 false,
1130 true,
1131 false,
1132 false,
1133 false,
1134 true,
1135 false,
1136 false,
1137 false,
1138 false,
1139 true,
1140 true,
1141 true,
1142 true,
1143 false,
1144 false,
1145 true,
1146 false,
1147 true,
1148 false,
1149 true,
1150 true,
1151 true,
1152 true,
1153 true,
1154 true,
1155 true,
1156 false,
1157 false,
1158 true,
1159 true,
1160 false,
1161 true,
1162 false,
1163 false,
1164 true,
1165 true,
1166 true,
1167 false,
1168 false,
1169 true,
1170 true,
1171 false,
1172 true,
1173 false,
1174 true,
1175 false,
1176 false,
1177 true,
1178 false,
1179 true,
1180 true,
1181 true,
1182 true,
1183 true,
1184 false,
1185 false,
1186 true,
1187 false,
1188 true,
1189 false,
1190 });
1191 c_test_vector_64_bool();
1192}
1193
1194comptime {
1195 skip: {
1196 if (builtin.zig_backend == .stage2_wasm) break :skip;
1197 if (builtin.cpu.arch == .hexagon) break :skip;
1198 if (builtin.cpu.arch == .loongarch64) break :skip;
1199 if (builtin.cpu.arch.isMIPS()) break :skip;
1200 if (builtin.cpu.arch.isPowerPC64()) break :skip;
1201 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
1202
1203 _ = struct {
1204 export fn zig_ret_vector_128_bool() @Vector(128, bool) {
1205 return .{
1206 true,
1207 true,
1208 false,
1209 false,
1210 false,
1211 true,
1212 true,
1213 false,
1214 false,
1215 true,
1216 false,
1217 false,
1218 false,
1219 true,
1220 false,
1221 true,
1222 true,
1223 false,
1224 false,
1225 true,
1226 true,
1227 true,
1228 true,
1229 true,
1230 false,
1231 false,
1232 true,
1233 true,
1234 true,
1235 false,
1236 false,
1237 true,
1238 true,
1239 false,
1240 true,
1241 true,
1242 true,
1243 false,
1244 true,
1245 true,
1246 true,
1247 false,
1248 true,
1249 true,
1250 false,
1251 false,
1252 false,
1253 true,
1254 false,
1255 false,
1256 false,
1257 false,
1258 true,
1259 false,
1260 true,
1261 false,
1262 true,
1263 false,
1264 false,
1265 true,
1266 true,
1267 true,
1268 true,
1269 true,
1270 false,
1271 false,
1272 false,
1273 true,
1274 true,
1275 false,
1276 true,
1277 true,
1278 false,
1279 true,
1280 true,
1281 false,
1282 false,
1283 true,
1284 false,
1285 true,
1286 false,
1287 false,
1288 true,
1289 true,
1290 false,
1291 true,
1292 false,
1293 false,
1294 true,
1295 true,
1296 true,
1297 true,
1298 true,
1299 false,
1300 false,
1301 true,
1302 false,
1303 false,
1304 true,
1305 true,
1306 true,
1307 true,
1308 true,
1309 true,
1310 true,
1311 false,
1312 false,
1313 true,
1314 false,
1315 false,
1316 true,
1317 false,
1318 false,
1319 true,
1320 false,
1321 false,
1322 false,
1323 false,
1324 false,
1325 false,
1326 true,
1327 true,
1328 true,
1329 false,
1330 true,
1331 false,
1332 false,
1333 true,
1334 };
1335 }
1336 export fn zig_vector_128_bool(vec: @Vector(128, bool)) void {
1337 expect(vec[0] == true) catch @panic("test failure");
1338 expect(vec[1] == true) catch @panic("test failure");
1339 expect(vec[2] == false) catch @panic("test failure");
1340 expect(vec[3] == true) catch @panic("test failure");
1341 expect(vec[4] == true) catch @panic("test failure");
1342 expect(vec[5] == false) catch @panic("test failure");
1343 expect(vec[6] == false) catch @panic("test failure");
1344 expect(vec[7] == true) catch @panic("test failure");
1345 expect(vec[8] == true) catch @panic("test failure");
1346 expect(vec[9] == true) catch @panic("test failure");
1347 expect(vec[10] == true) catch @panic("test failure");
1348 expect(vec[11] == true) catch @panic("test failure");
1349 expect(vec[12] == false) catch @panic("test failure");
1350 expect(vec[13] == false) catch @panic("test failure");
1351 expect(vec[14] == false) catch @panic("test failure");
1352 expect(vec[15] == true) catch @panic("test failure");
1353 expect(vec[16] == false) catch @panic("test failure");
1354 expect(vec[17] == true) catch @panic("test failure");
1355 expect(vec[18] == false) catch @panic("test failure");
1356 expect(vec[19] == false) catch @panic("test failure");
1357 expect(vec[20] == true) catch @panic("test failure");
1358 expect(vec[21] == false) catch @panic("test failure");
1359 expect(vec[22] == true) catch @panic("test failure");
1360 expect(vec[23] == false) catch @panic("test failure");
1361 expect(vec[24] == false) catch @panic("test failure");
1362 expect(vec[25] == false) catch @panic("test failure");
1363 expect(vec[26] == true) catch @panic("test failure");
1364 expect(vec[27] == false) catch @panic("test failure");
1365 expect(vec[28] == true) catch @panic("test failure");
1366 expect(vec[29] == true) catch @panic("test failure");
1367 expect(vec[30] == false) catch @panic("test failure");
1368 expect(vec[31] == true) catch @panic("test failure");
1369 expect(vec[32] == false) catch @panic("test failure");
1370 expect(vec[33] == true) catch @panic("test failure");
1371 expect(vec[34] == true) catch @panic("test failure");
1372 expect(vec[35] == false) catch @panic("test failure");
1373 expect(vec[36] == false) catch @panic("test failure");
1374 expect(vec[37] == false) catch @panic("test failure");
1375 expect(vec[38] == false) catch @panic("test failure");
1376 expect(vec[39] == true) catch @panic("test failure");
1377 expect(vec[40] == true) catch @panic("test failure");
1378 expect(vec[41] == false) catch @panic("test failure");
1379 expect(vec[42] == true) catch @panic("test failure");
1380 expect(vec[43] == false) catch @panic("test failure");
1381 expect(vec[44] == false) catch @panic("test failure");
1382 expect(vec[45] == true) catch @panic("test failure");
1383 expect(vec[46] == false) catch @panic("test failure");
1384 expect(vec[47] == false) catch @panic("test failure");
1385 expect(vec[48] == true) catch @panic("test failure");
1386 expect(vec[49] == true) catch @panic("test failure");
1387 expect(vec[50] == false) catch @panic("test failure");
1388 expect(vec[51] == false) catch @panic("test failure");
1389 expect(vec[52] == true) catch @panic("test failure");
1390 expect(vec[53] == false) catch @panic("test failure");
1391 expect(vec[54] == false) catch @panic("test failure");
1392 expect(vec[55] == true) catch @panic("test failure");
1393 expect(vec[56] == true) catch @panic("test failure");
1394 expect(vec[57] == true) catch @panic("test failure");
1395 expect(vec[58] == true) catch @panic("test failure");
1396 expect(vec[59] == true) catch @panic("test failure");
1397 expect(vec[60] == true) catch @panic("test failure");
1398 expect(vec[61] == true) catch @panic("test failure");
1399 expect(vec[62] == true) catch @panic("test failure");
1400 expect(vec[63] == false) catch @panic("test failure");
1401 expect(vec[64] == false) catch @panic("test failure");
1402 expect(vec[65] == true) catch @panic("test failure");
1403 expect(vec[66] == false) catch @panic("test failure");
1404 expect(vec[67] == true) catch @panic("test failure");
1405 expect(vec[68] == true) catch @panic("test failure");
1406 expect(vec[69] == true) catch @panic("test failure");
1407 expect(vec[70] == true) catch @panic("test failure");
1408 expect(vec[71] == false) catch @panic("test failure");
1409 expect(vec[72] == false) catch @panic("test failure");
1410 expect(vec[73] == false) catch @panic("test failure");
1411 expect(vec[74] == true) catch @panic("test failure");
1412 expect(vec[75] == true) catch @panic("test failure");
1413 expect(vec[76] == false) catch @panic("test failure");
1414 expect(vec[77] == true) catch @panic("test failure");
1415 expect(vec[78] == true) catch @panic("test failure");
1416 expect(vec[79] == true) catch @panic("test failure");
1417 expect(vec[80] == true) catch @panic("test failure");
1418 expect(vec[81] == false) catch @panic("test failure");
1419 expect(vec[82] == true) catch @panic("test failure");
1420 expect(vec[83] == true) catch @panic("test failure");
1421 expect(vec[84] == true) catch @panic("test failure");
1422 expect(vec[85] == true) catch @panic("test failure");
1423 expect(vec[86] == true) catch @panic("test failure");
1424 expect(vec[87] == true) catch @panic("test failure");
1425 expect(vec[88] == false) catch @panic("test failure");
1426 expect(vec[89] == true) catch @panic("test failure");
1427 expect(vec[90] == true) catch @panic("test failure");
1428 expect(vec[91] == true) catch @panic("test failure");
1429 expect(vec[92] == true) catch @panic("test failure");
1430 expect(vec[93] == true) catch @panic("test failure");
1431 expect(vec[94] == true) catch @panic("test failure");
1432 expect(vec[95] == false) catch @panic("test failure");
1433 expect(vec[96] == false) catch @panic("test failure");
1434 expect(vec[97] == false) catch @panic("test failure");
1435 expect(vec[98] == true) catch @panic("test failure");
1436 expect(vec[99] == true) catch @panic("test failure");
1437 expect(vec[100] == true) catch @panic("test failure");
1438 expect(vec[101] == true) catch @panic("test failure");
1439 expect(vec[102] == true) catch @panic("test failure");
1440 expect(vec[103] == true) catch @panic("test failure");
1441 expect(vec[104] == true) catch @panic("test failure");
1442 expect(vec[105] == false) catch @panic("test failure");
1443 expect(vec[106] == false) catch @panic("test failure");
1444 expect(vec[107] == false) catch @panic("test failure");
1445 expect(vec[108] == false) catch @panic("test failure");
1446 expect(vec[109] == false) catch @panic("test failure");
1447 expect(vec[110] == true) catch @panic("test failure");
1448 expect(vec[111] == true) catch @panic("test failure");
1449 expect(vec[112] == true) catch @panic("test failure");
1450 expect(vec[113] == false) catch @panic("test failure");
1451 expect(vec[114] == false) catch @panic("test failure");
1452 expect(vec[115] == false) catch @panic("test failure");
1453 expect(vec[116] == false) catch @panic("test failure");
1454 expect(vec[117] == false) catch @panic("test failure");
1455 expect(vec[118] == true) catch @panic("test failure");
1456 expect(vec[119] == false) catch @panic("test failure");
1457 expect(vec[120] == false) catch @panic("test failure");
1458 expect(vec[121] == false) catch @panic("test failure");
1459 expect(vec[122] == false) catch @panic("test failure");
1460 expect(vec[123] == true) catch @panic("test failure");
1461 expect(vec[124] == true) catch @panic("test failure");
1462 expect(vec[125] == false) catch @panic("test failure");
1463 expect(vec[126] == true) catch @panic("test failure");
1464 expect(vec[127] == false) catch @panic("test failure");
1465 }
1466 };
1467 }
1468}
1469
1470extern fn c_ret_vector_128_bool() @Vector(128, bool);
1471extern fn c_vector_128_bool(@Vector(128, bool)) void;
1472extern fn c_test_vector_128_bool() void;
1473
1474test "@Vector(128, bool)" {
1475 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
1476 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1477 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
1478 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
1479 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1480 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
1481
1482 const vec = c_ret_vector_128_bool();
1483 try expect(vec[0] == false);
1484 try expect(vec[1] == true);
1485 try expect(vec[2] == true);
1486 try expect(vec[3] == false);
1487 try expect(vec[4] == true);
1488 try expect(vec[5] == false);
1489 try expect(vec[6] == false);
1490 try expect(vec[7] == true);
1491 try expect(vec[8] == true);
1492 try expect(vec[9] == false);
1493 try expect(vec[10] == true);
1494 try expect(vec[11] == false);
1495 try expect(vec[12] == false);
1496 try expect(vec[13] == false);
1497 try expect(vec[14] == true);
1498 try expect(vec[15] == false);
1499 try expect(vec[16] == true);
1500 try expect(vec[17] == false);
1501 try expect(vec[18] == false);
1502 try expect(vec[19] == true);
1503 try expect(vec[20] == false);
1504 try expect(vec[21] == true);
1505 try expect(vec[22] == false);
1506 try expect(vec[23] == false);
1507 try expect(vec[24] == false);
1508 try expect(vec[25] == true);
1509 try expect(vec[26] == true);
1510 try expect(vec[27] == true);
1511 try expect(vec[28] == false);
1512 try expect(vec[29] == false);
1513 try expect(vec[30] == false);
1514 try expect(vec[31] == false);
1515 try expect(vec[32] == true);
1516 try expect(vec[33] == true);
1517 try expect(vec[34] == true);
1518 try expect(vec[35] == false);
1519 try expect(vec[36] == true);
1520 try expect(vec[37] == true);
1521 try expect(vec[38] == false);
1522 try expect(vec[39] == false);
1523 try expect(vec[40] == false);
1524 try expect(vec[41] == false);
1525 try expect(vec[42] == true);
1526 try expect(vec[43] == true);
1527 try expect(vec[44] == true);
1528 try expect(vec[45] == false);
1529 try expect(vec[46] == false);
1530 try expect(vec[47] == false);
1531 try expect(vec[48] == false);
1532 try expect(vec[49] == true);
1533 try expect(vec[50] == false);
1534 try expect(vec[51] == false);
1535 try expect(vec[52] == true);
1536 try expect(vec[53] == false);
1537 try expect(vec[54] == false);
1538 try expect(vec[55] == false);
1539 try expect(vec[56] == false);
1540 try expect(vec[57] == false);
1541 try expect(vec[58] == true);
1542 try expect(vec[59] == true);
1543 try expect(vec[60] == true);
1544 try expect(vec[61] == false);
1545 try expect(vec[62] == true);
1546 try expect(vec[63] == true);
1547 try expect(vec[64] == false);
1548 try expect(vec[65] == false);
1549 try expect(vec[66] == false);
1550 try expect(vec[67] == false);
1551 try expect(vec[68] == false);
1552 try expect(vec[69] == false);
1553 try expect(vec[70] == false);
1554 try expect(vec[71] == false);
1555 try expect(vec[72] == true);
1556 try expect(vec[73] == true);
1557 try expect(vec[74] == true);
1558 try expect(vec[75] == true);
1559 try expect(vec[76] == true);
1560 try expect(vec[77] == false);
1561 try expect(vec[78] == false);
1562 try expect(vec[79] == false);
1563 try expect(vec[80] == false);
1564 try expect(vec[81] == false);
1565 try expect(vec[82] == false);
1566 try expect(vec[83] == true);
1567 try expect(vec[84] == false);
1568 try expect(vec[85] == true);
1569 try expect(vec[86] == false);
1570 try expect(vec[87] == true);
1571 try expect(vec[88] == false);
1572 try expect(vec[89] == true);
1573 try expect(vec[90] == false);
1574 try expect(vec[91] == true);
1575 try expect(vec[92] == true);
1576 try expect(vec[93] == true);
1577 try expect(vec[94] == true);
1578 try expect(vec[95] == false);
1579 try expect(vec[96] == false);
1580 try expect(vec[97] == true);
1581 try expect(vec[98] == false);
1582 try expect(vec[99] == false);
1583 try expect(vec[100] == true);
1584 try expect(vec[101] == true);
1585 try expect(vec[102] == true);
1586 try expect(vec[103] == true);
1587 try expect(vec[104] == false);
1588 try expect(vec[105] == true);
1589 try expect(vec[106] == true);
1590 try expect(vec[107] == true);
1591 try expect(vec[108] == false);
1592 try expect(vec[109] == false);
1593 try expect(vec[110] == true);
1594 try expect(vec[111] == false);
1595 try expect(vec[112] == false);
1596 try expect(vec[113] == true);
1597 try expect(vec[114] == true);
1598 try expect(vec[115] == false);
1599 try expect(vec[116] == true);
1600 try expect(vec[117] == false);
1601 try expect(vec[118] == true);
1602 try expect(vec[119] == true);
1603 try expect(vec[120] == true);
1604 try expect(vec[121] == true);
1605 try expect(vec[122] == true);
1606 try expect(vec[123] == false);
1607 try expect(vec[124] == false);
1608 try expect(vec[125] == true);
1609 try expect(vec[126] == false);
1610 try expect(vec[127] == true);
1611 c_vector_128_bool(.{
1612 false,
1613 false,
1614 false,
1615 false,
1616 false,
1617 true,
1618 true,
1619 false,
1620 true,
1621 true,
1622 false,
1623 true,
1624 true,
1625 false,
1626 true,
1627 true,
1628 true,
1629 false,
1630 false,
1631 false,
1632 false,
1633 true,
1634 true,
1635 false,
1636 false,
1637 false,
1638 true,
1639 true,
1640 false,
1641 true,
1642 false,
1643 false,
1644 true,
1645 false,
1646 false,
1647 true,
1648 true,
1649 true,
1650 true,
1651 true,
1652 false,
1653 true,
1654 true,
1655 true,
1656 false,
1657 false,
1658 false,
1659 false,
1660 true,
1661 true,
1662 false,
1663 true,
1664 true,
1665 true,
1666 true,
1667 true,
1668 false,
1669 true,
1670 true,
1671 false,
1672 true,
1673 false,
1674 false,
1675 true,
1676 true,
1677 false,
1678 true,
1679 true,
1680 false,
1681 true,
1682 false,
1683 false,
1684 true,
1685 true,
1686 false,
1687 true,
1688 true,
1689 true,
1690 false,
1691 true,
1692 false,
1693 false,
1694 false,
1695 false,
1696 true,
1697 false,
1698 false,
1699 false,
1700 true,
1701 true,
1702 false,
1703 false,
1704 true,
1705 true,
1706 true,
1707 true,
1708 false,
1709 false,
1710 false,
1711 false,
1712 false,
1713 true,
1714 false,
1715 false,
1716 false,
1717 false,
1718 true,
1719 true,
1720 true,
1721 true,
1722 true,
1723 false,
1724 false,
1725 true,
1726 false,
1727 true,
1728 false,
1729 false,
1730 true,
1731 false,
1732 true,
1733 false,
1734 true,
1735 true,
1736 true,
1737 true,
1738 true,
1739 true,
1740 });
1741 c_test_vector_128_bool();
1742}
1743
1744comptime {
1745 skip: {
1746 if (builtin.zig_backend == .stage2_wasm) break :skip;
1747 if (builtin.cpu.arch == .hexagon) break :skip;
1748 if (builtin.cpu.arch == .loongarch64) break :skip;
1749 if (builtin.cpu.arch.isMIPS()) break :skip;
1750 if (builtin.cpu.arch.isPowerPC64()) break :skip;
1751 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
1752
1753 _ = struct {
1754 export fn zig_ret_vector_256_bool() @Vector(256, bool) {
1755 return .{
1756 true,
1757 true,
1758 true,
1759 false,
1760 true,
1761 false,
1762 false,
1763 true,
1764 false,
1765 false,
1766 false,
1767 false,
1768 false,
1769 false,
1770 false,
1771 false,
1772 true,
1773 false,
1774 true,
1775 false,
1776 false,
1777 true,
1778 true,
1779 false,
1780 false,
1781 true,
1782 true,
1783 false,
1784 true,
1785 true,
1786 true,
1787 false,
1788 true,
1789 false,
1790 true,
1791 false,
1792 true,
1793 false,
1794 true,
1795 false,
1796 false,
1797 false,
1798 true,
1799 true,
1800 true,
1801 false,
1802 false,
1803 false,
1804 true,
1805 false,
1806 true,
1807 false,
1808 true,
1809 false,
1810 true,
1811 true,
1812 false,
1813 false,
1814 false,
1815 true,
1816 true,
1817 true,
1818 false,
1819 true,
1820 false,
1821 true,
1822 false,
1823 true,
1824 true,
1825 false,
1826 true,
1827 false,
1828 true,
1829 true,
1830 false,
1831 false,
1832 false,
1833 false,
1834 false,
1835 false,
1836 false,
1837 false,
1838 false,
1839 true,
1840 false,
1841 false,
1842 false,
1843 true,
1844 false,
1845 true,
1846 true,
1847 false,
1848 false,
1849 true,
1850 true,
1851 false,
1852 false,
1853 true,
1854 false,
1855 false,
1856 false,
1857 false,
1858 false,
1859 false,
1860 false,
1861 true,
1862 true,
1863 false,
1864 true,
1865 false,
1866 true,
1867 true,
1868 false,
1869 false,
1870 false,
1871 false,
1872 false,
1873 false,
1874 false,
1875 true,
1876 true,
1877 true,
1878 false,
1879 true,
1880 true,
1881 false,
1882 false,
1883 true,
1884 true,
1885 true,
1886 true,
1887 true,
1888 false,
1889 true,
1890 true,
1891 false,
1892 false,
1893 true,
1894 true,
1895 false,
1896 true,
1897 false,
1898 true,
1899 false,
1900 true,
1901 true,
1902 true,
1903 true,
1904 false,
1905 false,
1906 false,
1907 true,
1908 false,
1909 true,
1910 false,
1911 true,
1912 true,
1913 false,
1914 true,
1915 true,
1916 true,
1917 true,
1918 true,
1919 false,
1920 false,
1921 true,
1922 false,
1923 true,
1924 true,
1925 true,
1926 true,
1927 false,
1928 true,
1929 true,
1930 true,
1931 true,
1932 true,
1933 true,
1934 true,
1935 false,
1936 true,
1937 false,
1938 false,
1939 false,
1940 true,
1941 false,
1942 true,
1943 true,
1944 false,
1945 true,
1946 false,
1947 true,
1948 false,
1949 true,
1950 false,
1951 false,
1952 true,
1953 true,
1954 true,
1955 true,
1956 true,
1957 true,
1958 true,
1959 false,
1960 true,
1961 false,
1962 false,
1963 true,
1964 true,
1965 false,
1966 false,
1967 false,
1968 true,
1969 true,
1970 true,
1971 false,
1972 false,
1973 true,
1974 true,
1975 true,
1976 true,
1977 false,
1978 true,
1979 false,
1980 true,
1981 true,
1982 true,
1983 false,
1984 false,
1985 false,
1986 false,
1987 false,
1988 true,
1989 true,
1990 false,
1991 false,
1992 false,
1993 true,
1994 true,
1995 false,
1996 true,
1997 true,
1998 true,
1999 false,
2000 true,
2001 true,
2002 false,
2003 true,
2004 false,
2005 false,
2006 true,
2007 true,
2008 false,
2009 true,
2010 false,
2011 true,
2012 };
2013 }
2014 export fn zig_vector_256_bool(vec: @Vector(256, bool)) void {
2015 expect(vec[0] == false) catch @panic("test failure");
2016 expect(vec[1] == false) catch @panic("test failure");
2017 expect(vec[2] == false) catch @panic("test failure");
2018 expect(vec[3] == false) catch @panic("test failure");
2019 expect(vec[4] == true) catch @panic("test failure");
2020 expect(vec[5] == true) catch @panic("test failure");
2021 expect(vec[6] == false) catch @panic("test failure");
2022 expect(vec[7] == false) catch @panic("test failure");
2023 expect(vec[8] == false) catch @panic("test failure");
2024 expect(vec[9] == true) catch @panic("test failure");
2025 expect(vec[10] == true) catch @panic("test failure");
2026 expect(vec[11] == false) catch @panic("test failure");
2027 expect(vec[12] == true) catch @panic("test failure");
2028 expect(vec[13] == false) catch @panic("test failure");
2029 expect(vec[14] == false) catch @panic("test failure");
2030 expect(vec[15] == false) catch @panic("test failure");
2031 expect(vec[16] == false) catch @panic("test failure");
2032 expect(vec[17] == true) catch @panic("test failure");
2033 expect(vec[18] == true) catch @panic("test failure");
2034 expect(vec[19] == true) catch @panic("test failure");
2035 expect(vec[20] == false) catch @panic("test failure");
2036 expect(vec[21] == true) catch @panic("test failure");
2037 expect(vec[22] == true) catch @panic("test failure");
2038 expect(vec[23] == false) catch @panic("test failure");
2039 expect(vec[24] == true) catch @panic("test failure");
2040 expect(vec[25] == false) catch @panic("test failure");
2041 expect(vec[26] == false) catch @panic("test failure");
2042 expect(vec[27] == true) catch @panic("test failure");
2043 expect(vec[28] == true) catch @panic("test failure");
2044 expect(vec[29] == true) catch @panic("test failure");
2045 expect(vec[30] == false) catch @panic("test failure");
2046 expect(vec[31] == true) catch @panic("test failure");
2047 expect(vec[32] == false) catch @panic("test failure");
2048 expect(vec[33] == true) catch @panic("test failure");
2049 expect(vec[34] == false) catch @panic("test failure");
2050 expect(vec[35] == false) catch @panic("test failure");
2051 expect(vec[36] == false) catch @panic("test failure");
2052 expect(vec[37] == true) catch @panic("test failure");
2053 expect(vec[38] == false) catch @panic("test failure");
2054 expect(vec[39] == false) catch @panic("test failure");
2055 expect(vec[40] == true) catch @panic("test failure");
2056 expect(vec[41] == true) catch @panic("test failure");
2057 expect(vec[42] == false) catch @panic("test failure");
2058 expect(vec[43] == true) catch @panic("test failure");
2059 expect(vec[44] == true) catch @panic("test failure");
2060 expect(vec[45] == false) catch @panic("test failure");
2061 expect(vec[46] == true) catch @panic("test failure");
2062 expect(vec[47] == false) catch @panic("test failure");
2063 expect(vec[48] == true) catch @panic("test failure");
2064 expect(vec[49] == false) catch @panic("test failure");
2065 expect(vec[50] == true) catch @panic("test failure");
2066 expect(vec[51] == false) catch @panic("test failure");
2067 expect(vec[52] == true) catch @panic("test failure");
2068 expect(vec[53] == true) catch @panic("test failure");
2069 expect(vec[54] == true) catch @panic("test failure");
2070 expect(vec[55] == false) catch @panic("test failure");
2071 expect(vec[56] == false) catch @panic("test failure");
2072 expect(vec[57] == true) catch @panic("test failure");
2073 expect(vec[58] == true) catch @panic("test failure");
2074 expect(vec[59] == false) catch @panic("test failure");
2075 expect(vec[60] == false) catch @panic("test failure");
2076 expect(vec[61] == true) catch @panic("test failure");
2077 expect(vec[62] == true) catch @panic("test failure");
2078 expect(vec[63] == false) catch @panic("test failure");
2079 expect(vec[64] == false) catch @panic("test failure");
2080 expect(vec[65] == false) catch @panic("test failure");
2081 expect(vec[66] == true) catch @panic("test failure");
2082 expect(vec[67] == true) catch @panic("test failure");
2083 expect(vec[68] == false) catch @panic("test failure");
2084 expect(vec[69] == true) catch @panic("test failure");
2085 expect(vec[70] == false) catch @panic("test failure");
2086 expect(vec[71] == true) catch @panic("test failure");
2087 expect(vec[72] == false) catch @panic("test failure");
2088 expect(vec[73] == true) catch @panic("test failure");
2089 expect(vec[74] == false) catch @panic("test failure");
2090 expect(vec[75] == false) catch @panic("test failure");
2091 expect(vec[76] == true) catch @panic("test failure");
2092 expect(vec[77] == false) catch @panic("test failure");
2093 expect(vec[78] == false) catch @panic("test failure");
2094 expect(vec[79] == false) catch @panic("test failure");
2095 expect(vec[80] == false) catch @panic("test failure");
2096 expect(vec[81] == false) catch @panic("test failure");
2097 expect(vec[82] == true) catch @panic("test failure");
2098 expect(vec[83] == false) catch @panic("test failure");
2099 expect(vec[84] == false) catch @panic("test failure");
2100 expect(vec[85] == false) catch @panic("test failure");
2101 expect(vec[86] == true) catch @panic("test failure");
2102 expect(vec[87] == true) catch @panic("test failure");
2103 expect(vec[88] == true) catch @panic("test failure");
2104 expect(vec[89] == false) catch @panic("test failure");
2105 expect(vec[90] == true) catch @panic("test failure");
2106 expect(vec[91] == false) catch @panic("test failure");
2107 expect(vec[92] == true) catch @panic("test failure");
2108 expect(vec[93] == false) catch @panic("test failure");
2109 expect(vec[94] == true) catch @panic("test failure");
2110 expect(vec[95] == true) catch @panic("test failure");
2111 expect(vec[96] == true) catch @panic("test failure");
2112 expect(vec[97] == true) catch @panic("test failure");
2113 expect(vec[98] == false) catch @panic("test failure");
2114 expect(vec[99] == true) catch @panic("test failure");
2115 expect(vec[100] == false) catch @panic("test failure");
2116 expect(vec[101] == true) catch @panic("test failure");
2117 expect(vec[102] == true) catch @panic("test failure");
2118 expect(vec[103] == false) catch @panic("test failure");
2119 expect(vec[104] == false) catch @panic("test failure");
2120 expect(vec[105] == true) catch @panic("test failure");
2121 expect(vec[106] == false) catch @panic("test failure");
2122 expect(vec[107] == true) catch @panic("test failure");
2123 expect(vec[108] == false) catch @panic("test failure");
2124 expect(vec[109] == false) catch @panic("test failure");
2125 expect(vec[110] == false) catch @panic("test failure");
2126 expect(vec[111] == false) catch @panic("test failure");
2127 expect(vec[112] == false) catch @panic("test failure");
2128 expect(vec[113] == false) catch @panic("test failure");
2129 expect(vec[114] == false) catch @panic("test failure");
2130 expect(vec[115] == false) catch @panic("test failure");
2131 expect(vec[116] == false) catch @panic("test failure");
2132 expect(vec[117] == false) catch @panic("test failure");
2133 expect(vec[118] == false) catch @panic("test failure");
2134 expect(vec[119] == false) catch @panic("test failure");
2135 expect(vec[120] == false) catch @panic("test failure");
2136 expect(vec[121] == false) catch @panic("test failure");
2137 expect(vec[122] == true) catch @panic("test failure");
2138 expect(vec[123] == true) catch @panic("test failure");
2139 expect(vec[124] == false) catch @panic("test failure");
2140 expect(vec[125] == false) catch @panic("test failure");
2141 expect(vec[126] == false) catch @panic("test failure");
2142 expect(vec[127] == true) catch @panic("test failure");
2143 expect(vec[128] == true) catch @panic("test failure");
2144 expect(vec[129] == true) catch @panic("test failure");
2145 expect(vec[130] == true) catch @panic("test failure");
2146 expect(vec[131] == false) catch @panic("test failure");
2147 expect(vec[132] == false) catch @panic("test failure");
2148 expect(vec[133] == false) catch @panic("test failure");
2149 expect(vec[134] == true) catch @panic("test failure");
2150 expect(vec[135] == true) catch @panic("test failure");
2151 expect(vec[136] == false) catch @panic("test failure");
2152 expect(vec[137] == false) catch @panic("test failure");
2153 expect(vec[138] == true) catch @panic("test failure");
2154 expect(vec[139] == true) catch @panic("test failure");
2155 expect(vec[140] == true) catch @panic("test failure");
2156 expect(vec[141] == true) catch @panic("test failure");
2157 expect(vec[142] == true) catch @panic("test failure");
2158 expect(vec[143] == false) catch @panic("test failure");
2159 expect(vec[144] == true) catch @panic("test failure");
2160 expect(vec[145] == true) catch @panic("test failure");
2161 expect(vec[146] == true) catch @panic("test failure");
2162 expect(vec[147] == false) catch @panic("test failure");
2163 expect(vec[148] == false) catch @panic("test failure");
2164 expect(vec[149] == false) catch @panic("test failure");
2165 expect(vec[150] == false) catch @panic("test failure");
2166 expect(vec[151] == false) catch @panic("test failure");
2167 expect(vec[152] == false) catch @panic("test failure");
2168 expect(vec[153] == false) catch @panic("test failure");
2169 expect(vec[154] == true) catch @panic("test failure");
2170 expect(vec[155] == false) catch @panic("test failure");
2171 expect(vec[156] == false) catch @panic("test failure");
2172 expect(vec[157] == false) catch @panic("test failure");
2173 expect(vec[158] == true) catch @panic("test failure");
2174 expect(vec[159] == true) catch @panic("test failure");
2175 expect(vec[160] == false) catch @panic("test failure");
2176 expect(vec[161] == true) catch @panic("test failure");
2177 expect(vec[162] == false) catch @panic("test failure");
2178 expect(vec[163] == false) catch @panic("test failure");
2179 expect(vec[164] == false) catch @panic("test failure");
2180 expect(vec[165] == true) catch @panic("test failure");
2181 expect(vec[166] == false) catch @panic("test failure");
2182 expect(vec[167] == true) catch @panic("test failure");
2183 expect(vec[168] == false) catch @panic("test failure");
2184 expect(vec[169] == false) catch @panic("test failure");
2185 expect(vec[170] == false) catch @panic("test failure");
2186 expect(vec[171] == false) catch @panic("test failure");
2187 expect(vec[172] == true) catch @panic("test failure");
2188 expect(vec[173] == true) catch @panic("test failure");
2189 expect(vec[174] == true) catch @panic("test failure");
2190 expect(vec[175] == true) catch @panic("test failure");
2191 expect(vec[176] == true) catch @panic("test failure");
2192 expect(vec[177] == true) catch @panic("test failure");
2193 expect(vec[178] == false) catch @panic("test failure");
2194 expect(vec[179] == true) catch @panic("test failure");
2195 expect(vec[180] == true) catch @panic("test failure");
2196 expect(vec[181] == false) catch @panic("test failure");
2197 expect(vec[182] == true) catch @panic("test failure");
2198 expect(vec[183] == false) catch @panic("test failure");
2199 expect(vec[184] == true) catch @panic("test failure");
2200 expect(vec[185] == false) catch @panic("test failure");
2201 expect(vec[186] == true) catch @panic("test failure");
2202 expect(vec[187] == false) catch @panic("test failure");
2203 expect(vec[188] == true) catch @panic("test failure");
2204 expect(vec[189] == false) catch @panic("test failure");
2205 expect(vec[190] == false) catch @panic("test failure");
2206 expect(vec[191] == false) catch @panic("test failure");
2207 expect(vec[192] == false) catch @panic("test failure");
2208 expect(vec[193] == true) catch @panic("test failure");
2209 expect(vec[194] == true) catch @panic("test failure");
2210 expect(vec[195] == true) catch @panic("test failure");
2211 expect(vec[196] == false) catch @panic("test failure");
2212 expect(vec[197] == false) catch @panic("test failure");
2213 expect(vec[198] == true) catch @panic("test failure");
2214 expect(vec[199] == false) catch @panic("test failure");
2215 expect(vec[200] == false) catch @panic("test failure");
2216 expect(vec[201] == true) catch @panic("test failure");
2217 expect(vec[202] == true) catch @panic("test failure");
2218 expect(vec[203] == false) catch @panic("test failure");
2219 expect(vec[204] == true) catch @panic("test failure");
2220 expect(vec[205] == false) catch @panic("test failure");
2221 expect(vec[206] == true) catch @panic("test failure");
2222 expect(vec[207] == false) catch @panic("test failure");
2223 expect(vec[208] == false) catch @panic("test failure");
2224 expect(vec[209] == false) catch @panic("test failure");
2225 expect(vec[210] == true) catch @panic("test failure");
2226 expect(vec[211] == true) catch @panic("test failure");
2227 expect(vec[212] == false) catch @panic("test failure");
2228 expect(vec[213] == false) catch @panic("test failure");
2229 expect(vec[214] == false) catch @panic("test failure");
2230 expect(vec[215] == true) catch @panic("test failure");
2231 expect(vec[216] == false) catch @panic("test failure");
2232 expect(vec[217] == true) catch @panic("test failure");
2233 expect(vec[218] == true) catch @panic("test failure");
2234 expect(vec[219] == true) catch @panic("test failure");
2235 expect(vec[220] == false) catch @panic("test failure");
2236 expect(vec[221] == true) catch @panic("test failure");
2237 expect(vec[222] == false) catch @panic("test failure");
2238 expect(vec[223] == true) catch @panic("test failure");
2239 expect(vec[224] == false) catch @panic("test failure");
2240 expect(vec[225] == false) catch @panic("test failure");
2241 expect(vec[226] == false) catch @panic("test failure");
2242 expect(vec[227] == true) catch @panic("test failure");
2243 expect(vec[228] == true) catch @panic("test failure");
2244 expect(vec[229] == false) catch @panic("test failure");
2245 expect(vec[230] == false) catch @panic("test failure");
2246 expect(vec[231] == false) catch @panic("test failure");
2247 expect(vec[232] == false) catch @panic("test failure");
2248 expect(vec[233] == false) catch @panic("test failure");
2249 expect(vec[234] == true) catch @panic("test failure");
2250 expect(vec[235] == false) catch @panic("test failure");
2251 expect(vec[236] == false) catch @panic("test failure");
2252 expect(vec[237] == false) catch @panic("test failure");
2253 expect(vec[238] == true) catch @panic("test failure");
2254 expect(vec[239] == false) catch @panic("test failure");
2255 expect(vec[240] == true) catch @panic("test failure");
2256 expect(vec[241] == true) catch @panic("test failure");
2257 expect(vec[242] == true) catch @panic("test failure");
2258 expect(vec[243] == false) catch @panic("test failure");
2259 expect(vec[244] == false) catch @panic("test failure");
2260 expect(vec[245] == true) catch @panic("test failure");
2261 expect(vec[246] == false) catch @panic("test failure");
2262 expect(vec[247] == false) catch @panic("test failure");
2263 expect(vec[248] == false) catch @panic("test failure");
2264 expect(vec[249] == true) catch @panic("test failure");
2265 expect(vec[250] == false) catch @panic("test failure");
2266 expect(vec[251] == false) catch @panic("test failure");
2267 expect(vec[252] == true) catch @panic("test failure");
2268 expect(vec[253] == true) catch @panic("test failure");
2269 expect(vec[254] == true) catch @panic("test failure");
2270 expect(vec[255] == true) catch @panic("test failure");
2271 }
2272 };
2273 }
2274}
2275
2276extern fn c_ret_vector_256_bool() @Vector(256, bool);
2277extern fn c_vector_256_bool(@Vector(256, bool)) void;
2278extern fn c_test_vector_256_bool() void;
2279
2280test "@Vector(256, bool)" {
2281 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
2282 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
2283 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
2284 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
2285 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
2286 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
2287
2288 const vec = c_ret_vector_256_bool();
2289 try expect(vec[0] == true);
2290 try expect(vec[1] == false);
2291 try expect(vec[2] == true);
2292 try expect(vec[3] == true);
2293 try expect(vec[4] == false);
2294 try expect(vec[5] == false);
2295 try expect(vec[6] == false);
2296 try expect(vec[7] == false);
2297 try expect(vec[8] == false);
2298 try expect(vec[9] == true);
2299 try expect(vec[10] == false);
2300 try expect(vec[11] == true);
2301 try expect(vec[12] == false);
2302 try expect(vec[13] == true);
2303 try expect(vec[14] == false);
2304 try expect(vec[15] == false);
2305 try expect(vec[16] == true);
2306 try expect(vec[17] == true);
2307 try expect(vec[18] == true);
2308 try expect(vec[19] == false);
2309 try expect(vec[20] == false);
2310 try expect(vec[21] == false);
2311 try expect(vec[22] == true);
2312 try expect(vec[23] == false);
2313 try expect(vec[24] == true);
2314 try expect(vec[25] == false);
2315 try expect(vec[26] == false);
2316 try expect(vec[27] == true);
2317 try expect(vec[28] == true);
2318 try expect(vec[29] == true);
2319 try expect(vec[30] == false);
2320 try expect(vec[31] == false);
2321 try expect(vec[32] == true);
2322 try expect(vec[33] == true);
2323 try expect(vec[34] == true);
2324 try expect(vec[35] == false);
2325 try expect(vec[36] == true);
2326 try expect(vec[37] == true);
2327 try expect(vec[38] == true);
2328 try expect(vec[39] == false);
2329 try expect(vec[40] == true);
2330 try expect(vec[41] == false);
2331 try expect(vec[42] == true);
2332 try expect(vec[43] == true);
2333 try expect(vec[44] == false);
2334 try expect(vec[45] == true);
2335 try expect(vec[46] == false);
2336 try expect(vec[47] == true);
2337 try expect(vec[48] == true);
2338 try expect(vec[49] == false);
2339 try expect(vec[50] == false);
2340 try expect(vec[51] == true);
2341 try expect(vec[52] == true);
2342 try expect(vec[53] == false);
2343 try expect(vec[54] == false);
2344 try expect(vec[55] == true);
2345 try expect(vec[56] == false);
2346 try expect(vec[57] == true);
2347 try expect(vec[58] == true);
2348 try expect(vec[59] == true);
2349 try expect(vec[60] == false);
2350 try expect(vec[61] == true);
2351 try expect(vec[62] == true);
2352 try expect(vec[63] == false);
2353 try expect(vec[64] == true);
2354 try expect(vec[65] == true);
2355 try expect(vec[66] == false);
2356 try expect(vec[67] == true);
2357 try expect(vec[68] == false);
2358 try expect(vec[69] == true);
2359 try expect(vec[70] == true);
2360 try expect(vec[71] == true);
2361 try expect(vec[72] == false);
2362 try expect(vec[73] == true);
2363 try expect(vec[74] == true);
2364 try expect(vec[75] == false);
2365 try expect(vec[76] == true);
2366 try expect(vec[77] == true);
2367 try expect(vec[78] == true);
2368 try expect(vec[79] == true);
2369 try expect(vec[80] == false);
2370 try expect(vec[81] == true);
2371 try expect(vec[82] == false);
2372 try expect(vec[83] == true);
2373 try expect(vec[84] == true);
2374 try expect(vec[85] == true);
2375 try expect(vec[86] == false);
2376 try expect(vec[87] == true);
2377 try expect(vec[88] == false);
2378 try expect(vec[89] == true);
2379 try expect(vec[90] == false);
2380 try expect(vec[91] == false);
2381 try expect(vec[92] == true);
2382 try expect(vec[93] == false);
2383 try expect(vec[94] == false);
2384 try expect(vec[95] == false);
2385 try expect(vec[96] == true);
2386 try expect(vec[97] == true);
2387 try expect(vec[98] == false);
2388 try expect(vec[99] == false);
2389 try expect(vec[100] == false);
2390 try expect(vec[101] == true);
2391 try expect(vec[102] == true);
2392 try expect(vec[103] == true);
2393 try expect(vec[104] == false);
2394 try expect(vec[105] == false);
2395 try expect(vec[106] == false);
2396 try expect(vec[107] == true);
2397 try expect(vec[108] == false);
2398 try expect(vec[109] == true);
2399 try expect(vec[110] == true);
2400 try expect(vec[111] == true);
2401 try expect(vec[112] == true);
2402 try expect(vec[113] == true);
2403 try expect(vec[114] == true);
2404 try expect(vec[115] == true);
2405 try expect(vec[116] == true);
2406 try expect(vec[117] == false);
2407 try expect(vec[118] == true);
2408 try expect(vec[119] == false);
2409 try expect(vec[120] == true);
2410 try expect(vec[121] == false);
2411 try expect(vec[122] == false);
2412 try expect(vec[123] == true);
2413 try expect(vec[124] == true);
2414 try expect(vec[125] == false);
2415 try expect(vec[126] == true);
2416 try expect(vec[127] == false);
2417 try expect(vec[128] == false);
2418 try expect(vec[129] == false);
2419 try expect(vec[130] == false);
2420 try expect(vec[131] == true);
2421 try expect(vec[132] == false);
2422 try expect(vec[133] == false);
2423 try expect(vec[134] == true);
2424 try expect(vec[135] == false);
2425 try expect(vec[136] == false);
2426 try expect(vec[137] == false);
2427 try expect(vec[138] == false);
2428 try expect(vec[139] == false);
2429 try expect(vec[140] == false);
2430 try expect(vec[141] == true);
2431 try expect(vec[142] == false);
2432 try expect(vec[143] == true);
2433 try expect(vec[144] == false);
2434 try expect(vec[145] == true);
2435 try expect(vec[146] == true);
2436 try expect(vec[147] == true);
2437 try expect(vec[148] == false);
2438 try expect(vec[149] == true);
2439 try expect(vec[150] == true);
2440 try expect(vec[151] == false);
2441 try expect(vec[152] == true);
2442 try expect(vec[153] == true);
2443 try expect(vec[154] == false);
2444 try expect(vec[155] == true);
2445 try expect(vec[156] == true);
2446 try expect(vec[157] == true);
2447 try expect(vec[158] == true);
2448 try expect(vec[159] == true);
2449 try expect(vec[160] == true);
2450 try expect(vec[161] == true);
2451 try expect(vec[162] == false);
2452 try expect(vec[163] == false);
2453 try expect(vec[164] == false);
2454 try expect(vec[165] == true);
2455 try expect(vec[166] == false);
2456 try expect(vec[167] == false);
2457 try expect(vec[168] == true);
2458 try expect(vec[169] == false);
2459 try expect(vec[170] == true);
2460 try expect(vec[171] == true);
2461 try expect(vec[172] == true);
2462 try expect(vec[173] == false);
2463 try expect(vec[174] == false);
2464 try expect(vec[175] == true);
2465 try expect(vec[176] == true);
2466 try expect(vec[177] == true);
2467 try expect(vec[178] == true);
2468 try expect(vec[179] == false);
2469 try expect(vec[180] == true);
2470 try expect(vec[181] == true);
2471 try expect(vec[182] == false);
2472 try expect(vec[183] == true);
2473 try expect(vec[184] == false);
2474 try expect(vec[185] == false);
2475 try expect(vec[186] == false);
2476 try expect(vec[187] == true);
2477 try expect(vec[188] == true);
2478 try expect(vec[189] == true);
2479 try expect(vec[190] == true);
2480 try expect(vec[191] == true);
2481 try expect(vec[192] == true);
2482 try expect(vec[193] == true);
2483 try expect(vec[194] == true);
2484 try expect(vec[195] == false);
2485 try expect(vec[196] == false);
2486 try expect(vec[197] == true);
2487 try expect(vec[198] == false);
2488 try expect(vec[199] == false);
2489 try expect(vec[200] == false);
2490 try expect(vec[201] == true);
2491 try expect(vec[202] == true);
2492 try expect(vec[203] == true);
2493 try expect(vec[204] == true);
2494 try expect(vec[205] == true);
2495 try expect(vec[206] == true);
2496 try expect(vec[207] == false);
2497 try expect(vec[208] == false);
2498 try expect(vec[209] == false);
2499 try expect(vec[210] == true);
2500 try expect(vec[211] == true);
2501 try expect(vec[212] == true);
2502 try expect(vec[213] == false);
2503 try expect(vec[214] == true);
2504 try expect(vec[215] == false);
2505 try expect(vec[216] == true);
2506 try expect(vec[217] == false);
2507 try expect(vec[218] == true);
2508 try expect(vec[219] == false);
2509 try expect(vec[220] == true);
2510 try expect(vec[221] == true);
2511 try expect(vec[222] == true);
2512 try expect(vec[223] == false);
2513 try expect(vec[224] == true);
2514 try expect(vec[225] == false);
2515 try expect(vec[226] == true);
2516 try expect(vec[227] == false);
2517 try expect(vec[228] == true);
2518 try expect(vec[229] == false);
2519 try expect(vec[230] == true);
2520 try expect(vec[231] == false);
2521 try expect(vec[232] == false);
2522 try expect(vec[233] == true);
2523 try expect(vec[234] == false);
2524 try expect(vec[235] == true);
2525 try expect(vec[236] == true);
2526 try expect(vec[237] == false);
2527 try expect(vec[238] == false);
2528 try expect(vec[239] == true);
2529 try expect(vec[240] == false);
2530 try expect(vec[241] == false);
2531 try expect(vec[242] == false);
2532 try expect(vec[243] == true);
2533 try expect(vec[244] == true);
2534 try expect(vec[245] == false);
2535 try expect(vec[246] == false);
2536 try expect(vec[247] == false);
2537 try expect(vec[248] == false);
2538 try expect(vec[249] == false);
2539 try expect(vec[250] == true);
2540 try expect(vec[251] == false);
2541 try expect(vec[252] == true);
2542 try expect(vec[253] == false);
2543 try expect(vec[254] == false);
2544 try expect(vec[255] == false);
2545 if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{
2546 false,
2547 true,
2548 true,
2549 false,
2550 false,
2551 true,
2552 true,
2553 true,
2554 false,
2555 true,
2556 true,
2557 true,
2558 false,
2559 true,
2560 false,
2561 true,
2562 false,
2563 false,
2564 true,
2565 true,
2566 false,
2567 true,
2568 false,
2569 false,
2570 false,
2571 true,
2572 true,
2573 false,
2574 false,
2575 true,
2576 true,
2577 false,
2578 true,
2579 false,
2580 false,
2581 true,
2582 false,
2583 true,
2584 false,
2585 true,
2586 true,
2587 true,
2588 true,
2589 false,
2590 false,
2591 true,
2592 false,
2593 false,
2594 false,
2595 false,
2596 false,
2597 false,
2598 true,
2599 true,
2600 true,
2601 true,
2602 true,
2603 true,
2604 false,
2605 true,
2606 true,
2607 false,
2608 false,
2609 true,
2610 false,
2611 false,
2612 false,
2613 false,
2614 false,
2615 false,
2616 true,
2617 true,
2618 true,
2619 false,
2620 false,
2621 false,
2622 true,
2623 false,
2624 true,
2625 true,
2626 false,
2627 false,
2628 true,
2629 true,
2630 false,
2631 true,
2632 true,
2633 true,
2634 true,
2635 true,
2636 true,
2637 true,
2638 false,
2639 true,
2640 true,
2641 false,
2642 false,
2643 true,
2644 true,
2645 false,
2646 true,
2647 false,
2648 false,
2649 true,
2650 false,
2651 true,
2652 true,
2653 true,
2654 true,
2655 true,
2656 false,
2657 false,
2658 false,
2659 false,
2660 true,
2661 true,
2662 false,
2663 true,
2664 false,
2665 false,
2666 true,
2667 false,
2668 false,
2669 true,
2670 false,
2671 true,
2672 true,
2673 true,
2674 true,
2675 false,
2676 true,
2677 true,
2678 false,
2679 false,
2680 true,
2681 false,
2682 false,
2683 true,
2684 false,
2685 true,
2686 false,
2687 true,
2688 true,
2689 true,
2690 true,
2691 false,
2692 true,
2693 false,
2694 false,
2695 false,
2696 true,
2697 true,
2698 true,
2699 true,
2700 true,
2701 false,
2702 true,
2703 false,
2704 false,
2705 false,
2706 true,
2707 true,
2708 false,
2709 true,
2710 true,
2711 false,
2712 false,
2713 false,
2714 false,
2715 true,
2716 false,
2717 true,
2718 false,
2719 false,
2720 false,
2721 false,
2722 true,
2723 true,
2724 true,
2725 false,
2726 true,
2727 false,
2728 true,
2729 true,
2730 false,
2731 false,
2732 true,
2733 false,
2734 false,
2735 false,
2736 false,
2737 true,
2738 true,
2739 true,
2740 true,
2741 true,
2742 true,
2743 true,
2744 false,
2745 true,
2746 false,
2747 false,
2748 true,
2749 false,
2750 true,
2751 true,
2752 true,
2753 false,
2754 false,
2755 true,
2756 true,
2757 true,
2758 false,
2759 true,
2760 true,
2761 true,
2762 true,
2763 true,
2764 false,
2765 false,
2766 false,
2767 false,
2768 false,
2769 true,
2770 true,
2771 false,
2772 true,
2773 false,
2774 false,
2775 true,
2776 false,
2777 true,
2778 false,
2779 false,
2780 false,
2781 true,
2782 false,
2783 false,
2784 false,
2785 true,
2786 true,
2787 true,
2788 true,
2789 true,
2790 true,
2791 false,
2792 false,
2793 true,
2794 false,
2795 true,
2796 true,
2797 false,
2798 true,
2799 true,
2800 true,
2801 false,
2802 });
2803 c_test_vector_512_bool();
2804}
2805
2806comptime {
2807 skip: {
2808 if (builtin.zig_backend == .stage2_wasm) break :skip;
2809 if (builtin.cpu.arch == .hexagon) break :skip;
2810 if (builtin.cpu.arch == .loongarch64) break :skip;
2811 if (builtin.cpu.arch.isMIPS()) break :skip;
2812 if (builtin.cpu.arch.isPowerPC64()) break :skip;
2813 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) break :skip;
2814
2815 _ = struct {
2816 export fn zig_ret_vector_512_bool() @Vector(512, bool) {
2817 return .{
2818 true,
2819 true,
2820 true,
2821 true,
2822 false,
2823 true,
2824 false,
2825 true,
2826 true,
2827 true,
2828 false,
2829 true,
2830 false,
2831 false,
2832 false,
2833 true,
2834 true,
2835 false,
2836 false,
2837 false,
2838 true,
2839 true,
2840 false,
2841 false,
2842 false,
2843 false,
2844 true,
2845 false,
2846 false,
2847 false,
2848 true,
2849 true,
2850 true,
2851 true,
2852 false,
2853 false,
2854 false,
2855 true,
2856 true,
2857 true,
2858 false,
2859 false,
2860 true,
2861 false,
2862 false,
2863 true,
2864 false,
2865 false,
2866 true,
2867 true,
2868 true,
2869 true,
2870 false,
2871 false,
2872 false,
2873 true,
2874 false,
2875 true,
2876 false,
2877 true,
2878 true,
2879 false,
2880 false,
2881 true,
2882 true,
2883 false,
2884 true,
2885 false,
2886 false,
2887 false,
2888 true,
2889 true,
2890 true,
2891 true,
2892 true,
2893 false,
2894 true,
2895 false,
2896 true,
2897 true,
2898 true,
2899 true,
2900 true,
2901 false,
2902 true,
2903 true,
2904 false,
2905 true,
2906 false,
2907 false,
2908 true,
2909 false,
2910 true,
2911 false,
2912 false,
2913 false,
2914 true,
2915 true,
2916 false,
2917 true,
2918 true,
2919 false,
2920 true,
2921 false,
2922 true,
2923 false,
2924 true,
2925 false,
2926 false,
2927 true,
2928 false,
2929 false,
2930 true,
2931 false,
2932 true,
2933 false,
2934 true,
2935 false,
2936 false,
2937 true,
2938 true,
2939 true,
2940 false,
2941 true,
2942 false,
2943 false,
2944 true,
2945 true,
2946 false,
2947 true,
2948 true,
2949 false,
2950 true,
2951 true,
2952 false,
2953 true,
2954 true,
2955 false,
2956 false,
2957 false,
2958 true,
2959 false,
2960 true,
2961 false,
2962 false,
2963 false,
2964 true,
2965 false,
2966 true,
2967 false,
2968 false,
2969 true,
2970 false,
2971 true,
2972 true,
2973 false,
2974 true,
2975 true,
2976 false,
2977 true,
2978 true,
2979 false,
2980 false,
2981 false,
2982 true,
2983 false,
2984 true,
2985 true,
2986 true,
2987 true,
2988 false,
2989 true,
2990 false,
2991 false,
2992 true,
2993 true,
2994 true,
2995 false,
2996 false,
2997 false,
2998 true,
2999 false,
3000 false,
3001 true,
3002 true,
3003 false,
3004 true,
3005 false,
3006 true,
3007 true,
3008 true,
3009 true,
3010 true,
3011 true,
3012 true,
3013 false,
3014 false,
3015 false,
3016 false,
3017 false,
3018 true,
3019 false,
3020 true,
3021 false,
3022 true,
3023 true,
3024 false,
3025 false,
3026 false,
3027 true,
3028 true,
3029 true,
3030 false,
3031 false,
3032 true,
3033 true,
3034 true,
3035 false,
3036 false,
3037 true,
3038 false,
3039 true,
3040 true,
3041 false,
3042 true,
3043 false,
3044 false,
3045 true,
3046 false,
3047 false,
3048 true,
3049 true,
3050 false,
3051 true,
3052 true,
3053 true,
3054 true,
3055 true,
3056 false,
3057 true,
3058 false,
3059 false,
3060 true,
3061 false,
3062 true,
3063 false,
3064 true,
3065 false,
3066 true,
3067 true,
3068 true,
3069 true,
3070 true,
3071 false,
3072 false,
3073 false,
3074 false,
3075 false,
3076 false,
3077 true,
3078 true,
3079 true,
3080 true,
3081 false,
3082 false,
3083 false,
3084 true,
3085 false,
3086 true,
3087 false,
3088 true,
3089 true,
3090 true,
3091 true,
3092 true,
3093 true,
3094 false,
3095 false,
3096 true,
3097 true,
3098 false,
3099 false,
3100 false,
3101 false,
3102 true,
3103 true,
3104 true,
3105 false,
3106 false,
3107 false,
3108 true,
3109 false,
3110 true,
3111 true,
3112 false,
3113 true,
3114 true,
3115 true,
3116 false,
3117 true,
3118 true,
3119 false,
3120 false,
3121 true,
3122 false,
3123 false,
3124 true,
3125 true,
3126 true,
3127 true,
3128 false,
3129 false,
3130 false,
3131 false,
3132 false,
3133 true,
3134 false,
3135 false,
3136 true,
3137 false,
3138 false,
3139 true,
3140 true,
3141 true,
3142 true,
3143 false,
3144 false,
3145 false,
3146 true,
3147 true,
3148 false,
3149 true,
3150 true,
3151 false,
3152 false,
3153 true,
3154 true,
3155 false,
3156 true,
3157 true,
3158 true,
3159 false,
3160 false,
3161 false,
3162 true,
3163 true,
3164 false,
3165 true,
3166 false,
3167 true,
3168 false,
3169 false,
3170 true,
3171 false,
3172 true,
3173 false,
3174 false,
3175 false,
3176 false,
3177 false,
3178 true,
3179 true,
3180 false,
3181 false,
3182 false,
3183 false,
3184 true,
3185 false,
3186 true,
3187 false,
3188 true,
3189 true,
3190 false,
3191 true,
3192 true,
3193 true,
3194 true,
3195 true,
3196 false,
3197 true,
3198 false,
3199 true,
3200 true,
3201 true,
3202 true,
3203 true,
3204 false,
3205 true,
3206 true,
3207 false,
3208 true,
3209 false,
3210 true,
3211 false,
3212 true,
3213 false,
3214 true,
3215 false,
3216 false,
3217 true,
3218 true,
3219 true,
3220 true,
3221 false,
3222 false,
3223 true,
3224 false,
3225 false,
3226 false,
3227 true,
3228 false,
3229 true,
3230 true,
3231 false,
3232 true,
3233 true,
3234 false,
3235 true,
3236 true,
3237 false,
3238 false,
3239 true,
3240 false,
3241 false,
3242 true,
3243 false,
3244 true,
3245 false,
3246 false,
3247 true,
3248 false,
3249 true,
3250 true,
3251 false,
3252 true,
3253 false,
3254 true,
3255 false,
3256 true,
3257 false,
3258 false,
3259 true,
3260 true,
3261 false,
3262 true,
3263 true,
3264 false,
3265 true,
3266 true,
3267 false,
3268 false,
3269 false,
3270 false,
3271 false,
3272 true,
3273 false,
3274 false,
3275 true,
3276 false,
3277 true,
3278 false,
3279 false,
3280 false,
3281 true,
3282 false,
3283 true,
3284 false,
3285 false,
3286 false,
3287 false,
3288 true,
3289 true,
3290 false,
3291 true,
3292 true,
3293 false,
3294 false,
3295 true,
3296 true,
3297 true,
3298 false,
3299 false,
3300 true,
3301 false,
3302 false,
3303 false,
3304 true,
3305 true,
3306 false,
3307 false,
3308 false,
3309 false,
3310 false,
3311 true,
3312 true,
3313 true,
3314 true,
3315 false,
3316 false,
3317 false,
3318 true,
3319 false,
3320 true,
3321 true,
3322 true,
3323 true,
3324 false,
3325 false,
3326 true,
3327 true,
3328 false,
3329 false,
3330 };
3331 }
3332 export fn zig_vector_512_bool(vec: @Vector(512, bool)) void {
3333 expect(vec[0] == false) catch @panic("test failure");
3334 expect(vec[1] == true) catch @panic("test failure");
3335 expect(vec[2] == true) catch @panic("test failure");
3336 expect(vec[3] == false) catch @panic("test failure");
3337 expect(vec[4] == true) catch @panic("test failure");
3338 expect(vec[5] == false) catch @panic("test failure");
3339 expect(vec[6] == true) catch @panic("test failure");
3340 expect(vec[7] == false) catch @panic("test failure");
3341 expect(vec[8] == false) catch @panic("test failure");
3342 expect(vec[9] == false) catch @panic("test failure");
3343 expect(vec[10] == false) catch @panic("test failure");
3344 expect(vec[11] == false) catch @panic("test failure");
3345 expect(vec[12] == true) catch @panic("test failure");
3346 expect(vec[13] == false) catch @panic("test failure");
3347 expect(vec[14] == true) catch @panic("test failure");
3348 expect(vec[15] == false) catch @panic("test failure");
3349 expect(vec[16] == false) catch @panic("test failure");
3350 expect(vec[17] == false) catch @panic("test failure");
3351 expect(vec[18] == true) catch @panic("test failure");
3352 expect(vec[19] == true) catch @panic("test failure");
3353 expect(vec[20] == true) catch @panic("test failure");
3354 expect(vec[21] == true) catch @panic("test failure");
3355 expect(vec[22] == false) catch @panic("test failure");
3356 expect(vec[23] == false) catch @panic("test failure");
3357 expect(vec[24] == false) catch @panic("test failure");
3358 expect(vec[25] == true) catch @panic("test failure");
3359 expect(vec[26] == true) catch @panic("test failure");
3360 expect(vec[27] == false) catch @panic("test failure");
3361 expect(vec[28] == true) catch @panic("test failure");
3362 expect(vec[29] == true) catch @panic("test failure");
3363 expect(vec[30] == false) catch @panic("test failure");
3364 expect(vec[31] == false) catch @panic("test failure");
3365 expect(vec[32] == true) catch @panic("test failure");
3366 expect(vec[33] == true) catch @panic("test failure");
3367 expect(vec[34] == false) catch @panic("test failure");
3368 expect(vec[35] == false) catch @panic("test failure");
3369 expect(vec[36] == false) catch @panic("test failure");
3370 expect(vec[37] == false) catch @panic("test failure");
3371 expect(vec[38] == false) catch @panic("test failure");
3372 expect(vec[39] == false) catch @panic("test failure");
3373 expect(vec[40] == false) catch @panic("test failure");
3374 expect(vec[41] == true) catch @panic("test failure");
3375 expect(vec[42] == true) catch @panic("test failure");
3376 expect(vec[43] == true) catch @panic("test failure");
3377 expect(vec[44] == false) catch @panic("test failure");
3378 expect(vec[45] == true) catch @panic("test failure");
3379 expect(vec[46] == true) catch @panic("test failure");
3380 expect(vec[47] == true) catch @panic("test failure");
3381 expect(vec[48] == true) catch @panic("test failure");
3382 expect(vec[49] == true) catch @panic("test failure");
3383 expect(vec[50] == false) catch @panic("test failure");
3384 expect(vec[51] == true) catch @panic("test failure");
3385 expect(vec[52] == true) catch @panic("test failure");
3386 expect(vec[53] == true) catch @panic("test failure");
3387 expect(vec[54] == false) catch @panic("test failure");
3388 expect(vec[55] == true) catch @panic("test failure");
3389 expect(vec[56] == false) catch @panic("test failure");
3390 expect(vec[57] == false) catch @panic("test failure");
3391 expect(vec[58] == true) catch @panic("test failure");
3392 expect(vec[59] == false) catch @panic("test failure");
3393 expect(vec[60] == true) catch @panic("test failure");
3394 expect(vec[61] == true) catch @panic("test failure");
3395 expect(vec[62] == false) catch @panic("test failure");
3396 expect(vec[63] == false) catch @panic("test failure");
3397 expect(vec[64] == false) catch @panic("test failure");
3398 expect(vec[65] == true) catch @panic("test failure");
3399 expect(vec[66] == true) catch @panic("test failure");
3400 expect(vec[67] == true) catch @panic("test failure");
3401 expect(vec[68] == true) catch @panic("test failure");
3402 expect(vec[69] == false) catch @panic("test failure");
3403 expect(vec[70] == false) catch @panic("test failure");
3404 expect(vec[71] == true) catch @panic("test failure");
3405 expect(vec[72] == true) catch @panic("test failure");
3406 expect(vec[73] == false) catch @panic("test failure");
3407 expect(vec[74] == true) catch @panic("test failure");
3408 expect(vec[75] == true) catch @panic("test failure");
3409 expect(vec[76] == false) catch @panic("test failure");
3410 expect(vec[77] == false) catch @panic("test failure");
3411 expect(vec[78] == true) catch @panic("test failure");
3412 expect(vec[79] == false) catch @panic("test failure");
3413 expect(vec[80] == false) catch @panic("test failure");
3414 expect(vec[81] == false) catch @panic("test failure");
3415 expect(vec[82] == true) catch @panic("test failure");
3416 expect(vec[83] == true) catch @panic("test failure");
3417 expect(vec[84] == true) catch @panic("test failure");
3418 expect(vec[85] == false) catch @panic("test failure");
3419 expect(vec[86] == false) catch @panic("test failure");
3420 expect(vec[87] == true) catch @panic("test failure");
3421 expect(vec[88] == false) catch @panic("test failure");
3422 expect(vec[89] == true) catch @panic("test failure");
3423 expect(vec[90] == false) catch @panic("test failure");
3424 expect(vec[91] == false) catch @panic("test failure");
3425 expect(vec[92] == true) catch @panic("test failure");
3426 expect(vec[93] == false) catch @panic("test failure");
3427 expect(vec[94] == false) catch @panic("test failure");
3428 expect(vec[95] == true) catch @panic("test failure");
3429 expect(vec[96] == true) catch @panic("test failure");
3430 expect(vec[97] == false) catch @panic("test failure");
3431 expect(vec[98] == false) catch @panic("test failure");
3432 expect(vec[99] == false) catch @panic("test failure");
3433 expect(vec[100] == false) catch @panic("test failure");
3434 expect(vec[101] == true) catch @panic("test failure");
3435 expect(vec[102] == false) catch @panic("test failure");
3436 expect(vec[103] == false) catch @panic("test failure");
3437 expect(vec[104] == false) catch @panic("test failure");
3438 expect(vec[105] == false) catch @panic("test failure");
3439 expect(vec[106] == false) catch @panic("test failure");
3440 expect(vec[107] == false) catch @panic("test failure");
3441 expect(vec[108] == true) catch @panic("test failure");
3442 expect(vec[109] == true) catch @panic("test failure");
3443 expect(vec[110] == true) catch @panic("test failure");
3444 expect(vec[111] == true) catch @panic("test failure");
3445 expect(vec[112] == true) catch @panic("test failure");
3446 expect(vec[113] == false) catch @panic("test failure");
3447 expect(vec[114] == false) catch @panic("test failure");
3448 expect(vec[115] == false) catch @panic("test failure");
3449 expect(vec[116] == false) catch @panic("test failure");
3450 expect(vec[117] == true) catch @panic("test failure");
3451 expect(vec[118] == true) catch @panic("test failure");
3452 expect(vec[119] == false) catch @panic("test failure");
3453 expect(vec[120] == true) catch @panic("test failure");
3454 expect(vec[121] == true) catch @panic("test failure");
3455 expect(vec[122] == false) catch @panic("test failure");
3456 expect(vec[123] == false) catch @panic("test failure");
3457 expect(vec[124] == true) catch @panic("test failure");
3458 expect(vec[125] == false) catch @panic("test failure");
3459 expect(vec[126] == false) catch @panic("test failure");
3460 expect(vec[127] == false) catch @panic("test failure");
3461 expect(vec[128] == false) catch @panic("test failure");
3462 expect(vec[129] == true) catch @panic("test failure");
3463 expect(vec[130] == true) catch @panic("test failure");
3464 expect(vec[131] == true) catch @panic("test failure");
3465 expect(vec[132] == true) catch @panic("test failure");
3466 expect(vec[133] == false) catch @panic("test failure");
3467 expect(vec[134] == false) catch @panic("test failure");
3468 expect(vec[135] == false) catch @panic("test failure");
3469 expect(vec[136] == false) catch @panic("test failure");
3470 expect(vec[137] == true) catch @panic("test failure");
3471 expect(vec[138] == false) catch @panic("test failure");
3472 expect(vec[139] == false) catch @panic("test failure");
3473 expect(vec[140] == false) catch @panic("test failure");
3474 expect(vec[141] == false) catch @panic("test failure");
3475 expect(vec[142] == true) catch @panic("test failure");
3476 expect(vec[143] == true) catch @panic("test failure");
3477 expect(vec[144] == false) catch @panic("test failure");
3478 expect(vec[145] == true) catch @panic("test failure");
3479 expect(vec[146] == false) catch @panic("test failure");
3480 expect(vec[147] == true) catch @panic("test failure");
3481 expect(vec[148] == false) catch @panic("test failure");
3482 expect(vec[149] == false) catch @panic("test failure");
3483 expect(vec[150] == true) catch @panic("test failure");
3484 expect(vec[151] == true) catch @panic("test failure");
3485 expect(vec[152] == false) catch @panic("test failure");
3486 expect(vec[153] == true) catch @panic("test failure");
3487 expect(vec[154] == true) catch @panic("test failure");
3488 expect(vec[155] == false) catch @panic("test failure");
3489 expect(vec[156] == false) catch @panic("test failure");
3490 expect(vec[157] == false) catch @panic("test failure");
3491 expect(vec[158] == true) catch @panic("test failure");
3492 expect(vec[159] == false) catch @panic("test failure");
3493 expect(vec[160] == false) catch @panic("test failure");
3494 expect(vec[161] == false) catch @panic("test failure");
3495 expect(vec[162] == false) catch @panic("test failure");
3496 expect(vec[163] == true) catch @panic("test failure");
3497 expect(vec[164] == true) catch @panic("test failure");
3498 expect(vec[165] == false) catch @panic("test failure");
3499 expect(vec[166] == false) catch @panic("test failure");
3500 expect(vec[167] == true) catch @panic("test failure");
3501 expect(vec[168] == false) catch @panic("test failure");
3502 expect(vec[169] == true) catch @panic("test failure");
3503 expect(vec[170] == true) catch @panic("test failure");
3504 expect(vec[171] == false) catch @panic("test failure");
3505 expect(vec[172] == false) catch @panic("test failure");
3506 expect(vec[173] == false) catch @panic("test failure");
3507 expect(vec[174] == false) catch @panic("test failure");
3508 expect(vec[175] == false) catch @panic("test failure");
3509 expect(vec[176] == false) catch @panic("test failure");
3510 expect(vec[177] == true) catch @panic("test failure");
3511 expect(vec[178] == false) catch @panic("test failure");
3512 expect(vec[179] == false) catch @panic("test failure");
3513 expect(vec[180] == false) catch @panic("test failure");
3514 expect(vec[181] == false) catch @panic("test failure");
3515 expect(vec[182] == false) catch @panic("test failure");
3516 expect(vec[183] == false) catch @panic("test failure");
3517 expect(vec[184] == true) catch @panic("test failure");
3518 expect(vec[185] == false) catch @panic("test failure");
3519 expect(vec[186] == false) catch @panic("test failure");
3520 expect(vec[187] == false) catch @panic("test failure");
3521 expect(vec[188] == false) catch @panic("test failure");
3522 expect(vec[189] == true) catch @panic("test failure");
3523 expect(vec[190] == false) catch @panic("test failure");
3524 expect(vec[191] == false) catch @panic("test failure");
3525 expect(vec[192] == false) catch @panic("test failure");
3526 expect(vec[193] == false) catch @panic("test failure");
3527 expect(vec[194] == false) catch @panic("test failure");
3528 expect(vec[195] == false) catch @panic("test failure");
3529 expect(vec[196] == true) catch @panic("test failure");
3530 expect(vec[197] == true) catch @panic("test failure");
3531 expect(vec[198] == true) catch @panic("test failure");
3532 expect(vec[199] == false) catch @panic("test failure");
3533 expect(vec[200] == true) catch @panic("test failure");
3534 expect(vec[201] == true) catch @panic("test failure");
3535 expect(vec[202] == false) catch @panic("test failure");
3536 expect(vec[203] == false) catch @panic("test failure");
3537 expect(vec[204] == false) catch @panic("test failure");
3538 expect(vec[205] == false) catch @panic("test failure");
3539 expect(vec[206] == false) catch @panic("test failure");
3540 expect(vec[207] == true) catch @panic("test failure");
3541 expect(vec[208] == true) catch @panic("test failure");
3542 expect(vec[209] == false) catch @panic("test failure");
3543 expect(vec[210] == false) catch @panic("test failure");
3544 expect(vec[211] == false) catch @panic("test failure");
3545 expect(vec[212] == true) catch @panic("test failure");
3546 expect(vec[213] == false) catch @panic("test failure");
3547 expect(vec[214] == false) catch @panic("test failure");
3548 expect(vec[215] == true) catch @panic("test failure");
3549 expect(vec[216] == true) catch @panic("test failure");
3550 expect(vec[217] == true) catch @panic("test failure");
3551 expect(vec[218] == false) catch @panic("test failure");
3552 expect(vec[219] == false) catch @panic("test failure");
3553 expect(vec[220] == true) catch @panic("test failure");
3554 expect(vec[221] == false) catch @panic("test failure");
3555 expect(vec[222] == true) catch @panic("test failure");
3556 expect(vec[223] == true) catch @panic("test failure");
3557 expect(vec[224] == true) catch @panic("test failure");
3558 expect(vec[225] == true) catch @panic("test failure");
3559 expect(vec[226] == false) catch @panic("test failure");
3560 expect(vec[227] == true) catch @panic("test failure");
3561 expect(vec[228] == false) catch @panic("test failure");
3562 expect(vec[229] == false) catch @panic("test failure");
3563 expect(vec[230] == false) catch @panic("test failure");
3564 expect(vec[231] == true) catch @panic("test failure");
3565 expect(vec[232] == false) catch @panic("test failure");
3566 expect(vec[233] == false) catch @panic("test failure");
3567 expect(vec[234] == false) catch @panic("test failure");
3568 expect(vec[235] == false) catch @panic("test failure");
3569 expect(vec[236] == false) catch @panic("test failure");
3570 expect(vec[237] == false) catch @panic("test failure");
3571 expect(vec[238] == false) catch @panic("test failure");
3572 expect(vec[239] == true) catch @panic("test failure");
3573 expect(vec[240] == false) catch @panic("test failure");
3574 expect(vec[241] == false) catch @panic("test failure");
3575 expect(vec[242] == false) catch @panic("test failure");
3576 expect(vec[243] == true) catch @panic("test failure");
3577 expect(vec[244] == true) catch @panic("test failure");
3578 expect(vec[245] == true) catch @panic("test failure");
3579 expect(vec[246] == true) catch @panic("test failure");
3580 expect(vec[247] == false) catch @panic("test failure");
3581 expect(vec[248] == true) catch @panic("test failure");
3582 expect(vec[249] == true) catch @panic("test failure");
3583 expect(vec[250] == false) catch @panic("test failure");
3584 expect(vec[251] == false) catch @panic("test failure");
3585 expect(vec[252] == false) catch @panic("test failure");
3586 expect(vec[253] == true) catch @panic("test failure");
3587 expect(vec[254] == false) catch @panic("test failure");
3588 expect(vec[255] == false) catch @panic("test failure");
3589 expect(vec[256] == true) catch @panic("test failure");
3590 expect(vec[257] == true) catch @panic("test failure");
3591 expect(vec[258] == false) catch @panic("test failure");
3592 expect(vec[259] == true) catch @panic("test failure");
3593 expect(vec[260] == false) catch @panic("test failure");
3594 expect(vec[261] == true) catch @panic("test failure");
3595 expect(vec[262] == true) catch @panic("test failure");
3596 expect(vec[263] == false) catch @panic("test failure");
3597 expect(vec[264] == false) catch @panic("test failure");
3598 expect(vec[265] == false) catch @panic("test failure");
3599 expect(vec[266] == false) catch @panic("test failure");
3600 expect(vec[267] == true) catch @panic("test failure");
3601 expect(vec[268] == false) catch @panic("test failure");
3602 expect(vec[269] == true) catch @panic("test failure");
3603 expect(vec[270] == true) catch @panic("test failure");
3604 expect(vec[271] == false) catch @panic("test failure");
3605 expect(vec[272] == false) catch @panic("test failure");
3606 expect(vec[273] == true) catch @panic("test failure");
3607 expect(vec[274] == true) catch @panic("test failure");
3608 expect(vec[275] == true) catch @panic("test failure");
3609 expect(vec[276] == false) catch @panic("test failure");
3610 expect(vec[277] == true) catch @panic("test failure");
3611 expect(vec[278] == false) catch @panic("test failure");
3612 expect(vec[279] == false) catch @panic("test failure");
3613 expect(vec[280] == true) catch @panic("test failure");
3614 expect(vec[281] == true) catch @panic("test failure");
3615 expect(vec[282] == false) catch @panic("test failure");
3616 expect(vec[283] == true) catch @panic("test failure");
3617 expect(vec[284] == false) catch @panic("test failure");
3618 expect(vec[285] == true) catch @panic("test failure");
3619 expect(vec[286] == true) catch @panic("test failure");
3620 expect(vec[287] == true) catch @panic("test failure");
3621 expect(vec[288] == true) catch @panic("test failure");
3622 expect(vec[289] == true) catch @panic("test failure");
3623 expect(vec[290] == true) catch @panic("test failure");
3624 expect(vec[291] == true) catch @panic("test failure");
3625 expect(vec[292] == true) catch @panic("test failure");
3626 expect(vec[293] == true) catch @panic("test failure");
3627 expect(vec[294] == true) catch @panic("test failure");
3628 expect(vec[295] == false) catch @panic("test failure");
3629 expect(vec[296] == true) catch @panic("test failure");
3630 expect(vec[297] == false) catch @panic("test failure");
3631 expect(vec[298] == true) catch @panic("test failure");
3632 expect(vec[299] == false) catch @panic("test failure");
3633 expect(vec[300] == true) catch @panic("test failure");
3634 expect(vec[301] == true) catch @panic("test failure");
3635 expect(vec[302] == false) catch @panic("test failure");
3636 expect(vec[303] == true) catch @panic("test failure");
3637 expect(vec[304] == false) catch @panic("test failure");
3638 expect(vec[305] == true) catch @panic("test failure");
3639 expect(vec[306] == false) catch @panic("test failure");
3640 expect(vec[307] == true) catch @panic("test failure");
3641 expect(vec[308] == true) catch @panic("test failure");
3642 expect(vec[309] == false) catch @panic("test failure");
3643 expect(vec[310] == true) catch @panic("test failure");
3644 expect(vec[311] == true) catch @panic("test failure");
3645 expect(vec[312] == true) catch @panic("test failure");
3646 expect(vec[313] == false) catch @panic("test failure");
3647 expect(vec[314] == false) catch @panic("test failure");
3648 expect(vec[315] == false) catch @panic("test failure");
3649 expect(vec[316] == false) catch @panic("test failure");
3650 expect(vec[317] == true) catch @panic("test failure");
3651 expect(vec[318] == true) catch @panic("test failure");
3652 expect(vec[319] == true) catch @panic("test failure");
3653 expect(vec[320] == true) catch @panic("test failure");
3654 expect(vec[321] == true) catch @panic("test failure");
3655 expect(vec[322] == true) catch @panic("test failure");
3656 expect(vec[323] == true) catch @panic("test failure");
3657 expect(vec[324] == true) catch @panic("test failure");
3658 expect(vec[325] == true) catch @panic("test failure");
3659 expect(vec[326] == false) catch @panic("test failure");
3660 expect(vec[327] == true) catch @panic("test failure");
3661 expect(vec[328] == false) catch @panic("test failure");
3662 expect(vec[329] == false) catch @panic("test failure");
3663 expect(vec[330] == true) catch @panic("test failure");
3664 expect(vec[331] == false) catch @panic("test failure");
3665 expect(vec[332] == false) catch @panic("test failure");
3666 expect(vec[333] == false) catch @panic("test failure");
3667 expect(vec[334] == false) catch @panic("test failure");
3668 expect(vec[335] == false) catch @panic("test failure");
3669 expect(vec[336] == false) catch @panic("test failure");
3670 expect(vec[337] == false) catch @panic("test failure");
3671 expect(vec[338] == false) catch @panic("test failure");
3672 expect(vec[339] == false) catch @panic("test failure");
3673 expect(vec[340] == false) catch @panic("test failure");
3674 expect(vec[341] == false) catch @panic("test failure");
3675 expect(vec[342] == true) catch @panic("test failure");
3676 expect(vec[343] == true) catch @panic("test failure");
3677 expect(vec[344] == false) catch @panic("test failure");
3678 expect(vec[345] == false) catch @panic("test failure");
3679 expect(vec[346] == false) catch @panic("test failure");
3680 expect(vec[347] == false) catch @panic("test failure");
3681 expect(vec[348] == false) catch @panic("test failure");
3682 expect(vec[349] == true) catch @panic("test failure");
3683 expect(vec[350] == true) catch @panic("test failure");
3684 expect(vec[351] == true) catch @panic("test failure");
3685 expect(vec[352] == true) catch @panic("test failure");
3686 expect(vec[353] == false) catch @panic("test failure");
3687 expect(vec[354] == false) catch @panic("test failure");
3688 expect(vec[355] == false) catch @panic("test failure");
3689 expect(vec[356] == false) catch @panic("test failure");
3690 expect(vec[357] == true) catch @panic("test failure");
3691 expect(vec[358] == true) catch @panic("test failure");
3692 expect(vec[359] == false) catch @panic("test failure");
3693 expect(vec[360] == false) catch @panic("test failure");
3694 expect(vec[361] == false) catch @panic("test failure");
3695 expect(vec[362] == true) catch @panic("test failure");
3696 expect(vec[363] == true) catch @panic("test failure");
3697 expect(vec[364] == false) catch @panic("test failure");
3698 expect(vec[365] == false) catch @panic("test failure");
3699 expect(vec[366] == false) catch @panic("test failure");
3700 expect(vec[367] == false) catch @panic("test failure");
3701 expect(vec[368] == false) catch @panic("test failure");
3702 expect(vec[369] == true) catch @panic("test failure");
3703 expect(vec[370] == true) catch @panic("test failure");
3704 expect(vec[371] == false) catch @panic("test failure");
3705 expect(vec[372] == true) catch @panic("test failure");
3706 expect(vec[373] == true) catch @panic("test failure");
3707 expect(vec[374] == false) catch @panic("test failure");
3708 expect(vec[375] == true) catch @panic("test failure");
3709 expect(vec[376] == true) catch @panic("test failure");
3710 expect(vec[377] == false) catch @panic("test failure");
3711 expect(vec[378] == true) catch @panic("test failure");
3712 expect(vec[379] == true) catch @panic("test failure");
3713 expect(vec[380] == false) catch @panic("test failure");
3714 expect(vec[381] == true) catch @panic("test failure");
3715 expect(vec[382] == true) catch @panic("test failure");
3716 expect(vec[383] == false) catch @panic("test failure");
3717 expect(vec[384] == true) catch @panic("test failure");
3718 expect(vec[385] == false) catch @panic("test failure");
3719 expect(vec[386] == true) catch @panic("test failure");
3720 expect(vec[387] == true) catch @panic("test failure");
3721 expect(vec[388] == true) catch @panic("test failure");
3722 expect(vec[389] == true) catch @panic("test failure");
3723 expect(vec[390] == false) catch @panic("test failure");
3724 expect(vec[391] == false) catch @panic("test failure");
3725 expect(vec[392] == false) catch @panic("test failure");
3726 expect(vec[393] == true) catch @panic("test failure");
3727 expect(vec[394] == true) catch @panic("test failure");
3728 expect(vec[395] == true) catch @panic("test failure");
3729 expect(vec[396] == true) catch @panic("test failure");
3730 expect(vec[397] == false) catch @panic("test failure");
3731 expect(vec[398] == true) catch @panic("test failure");
3732 expect(vec[399] == true) catch @panic("test failure");
3733 expect(vec[400] == true) catch @panic("test failure");
3734 expect(vec[401] == false) catch @panic("test failure");
3735 expect(vec[402] == false) catch @panic("test failure");
3736 expect(vec[403] == true) catch @panic("test failure");
3737 expect(vec[404] == false) catch @panic("test failure");
3738 expect(vec[405] == false) catch @panic("test failure");
3739 expect(vec[406] == false) catch @panic("test failure");
3740 expect(vec[407] == true) catch @panic("test failure");
3741 expect(vec[408] == true) catch @panic("test failure");
3742 expect(vec[409] == true) catch @panic("test failure");
3743 expect(vec[410] == false) catch @panic("test failure");
3744 expect(vec[411] == true) catch @panic("test failure");
3745 expect(vec[412] == false) catch @panic("test failure");
3746 expect(vec[413] == false) catch @panic("test failure");
3747 expect(vec[414] == false) catch @panic("test failure");
3748 expect(vec[415] == true) catch @panic("test failure");
3749 expect(vec[416] == false) catch @panic("test failure");
3750 expect(vec[417] == false) catch @panic("test failure");
3751 expect(vec[418] == true) catch @panic("test failure");
3752 expect(vec[419] == true) catch @panic("test failure");
3753 expect(vec[420] == true) catch @panic("test failure");
3754 expect(vec[421] == true) catch @panic("test failure");
3755 expect(vec[422] == false) catch @panic("test failure");
3756 expect(vec[423] == true) catch @panic("test failure");
3757 expect(vec[424] == true) catch @panic("test failure");
3758 expect(vec[425] == false) catch @panic("test failure");
3759 expect(vec[426] == false) catch @panic("test failure");
3760 expect(vec[427] == false) catch @panic("test failure");
3761 expect(vec[428] == true) catch @panic("test failure");
3762 expect(vec[429] == false) catch @panic("test failure");
3763 expect(vec[430] == true) catch @panic("test failure");
3764 expect(vec[431] == true) catch @panic("test failure");
3765 expect(vec[432] == false) catch @panic("test failure");
3766 expect(vec[433] == false) catch @panic("test failure");
3767 expect(vec[434] == false) catch @panic("test failure");
3768 expect(vec[435] == false) catch @panic("test failure");
3769 expect(vec[436] == true) catch @panic("test failure");
3770 expect(vec[437] == false) catch @panic("test failure");
3771 expect(vec[438] == true) catch @panic("test failure");
3772 expect(vec[439] == false) catch @panic("test failure");
3773 expect(vec[440] == false) catch @panic("test failure");
3774 expect(vec[441] == false) catch @panic("test failure");
3775 expect(vec[442] == false) catch @panic("test failure");
3776 expect(vec[443] == true) catch @panic("test failure");
3777 expect(vec[444] == false) catch @panic("test failure");
3778 expect(vec[445] == false) catch @panic("test failure");
3779 expect(vec[446] == true) catch @panic("test failure");
3780 expect(vec[447] == true) catch @panic("test failure");
3781 expect(vec[448] == true) catch @panic("test failure");
3782 expect(vec[449] == false) catch @panic("test failure");
3783 expect(vec[450] == true) catch @panic("test failure");
3784 expect(vec[451] == true) catch @panic("test failure");
3785 expect(vec[452] == false) catch @panic("test failure");
3786 expect(vec[453] == true) catch @panic("test failure");
3787 expect(vec[454] == false) catch @panic("test failure");
3788 expect(vec[455] == true) catch @panic("test failure");
3789 expect(vec[456] == false) catch @panic("test failure");
3790 expect(vec[457] == false) catch @panic("test failure");
3791 expect(vec[458] == false) catch @panic("test failure");
3792 expect(vec[459] == true) catch @panic("test failure");
3793 expect(vec[460] == false) catch @panic("test failure");
3794 expect(vec[461] == false) catch @panic("test failure");
3795 expect(vec[462] == false) catch @panic("test failure");
3796 expect(vec[463] == true) catch @panic("test failure");
3797 expect(vec[464] == true) catch @panic("test failure");
3798 expect(vec[465] == true) catch @panic("test failure");
3799 expect(vec[466] == true) catch @panic("test failure");
3800 expect(vec[467] == true) catch @panic("test failure");
3801 expect(vec[468] == false) catch @panic("test failure");
3802 expect(vec[469] == false) catch @panic("test failure");
3803 expect(vec[470] == false) catch @panic("test failure");
3804 expect(vec[471] == false) catch @panic("test failure");
3805 expect(vec[472] == false) catch @panic("test failure");
3806 expect(vec[473] == false) catch @panic("test failure");
3807 expect(vec[474] == true) catch @panic("test failure");
3808 expect(vec[475] == true) catch @panic("test failure");
3809 expect(vec[476] == true) catch @panic("test failure");
3810 expect(vec[477] == true) catch @panic("test failure");
3811 expect(vec[478] == true) catch @panic("test failure");
3812 expect(vec[479] == false) catch @panic("test failure");
3813 expect(vec[480] == true) catch @panic("test failure");
3814 expect(vec[481] == true) catch @panic("test failure");
3815 expect(vec[482] == false) catch @panic("test failure");
3816 expect(vec[483] == true) catch @panic("test failure");
3817 expect(vec[484] == false) catch @panic("test failure");
3818 expect(vec[485] == true) catch @panic("test failure");
3819 expect(vec[486] == false) catch @panic("test failure");
3820 expect(vec[487] == true) catch @panic("test failure");
3821 expect(vec[488] == false) catch @panic("test failure");
3822 expect(vec[489] == false) catch @panic("test failure");
3823 expect(vec[490] == false) catch @panic("test failure");
3824 expect(vec[491] == true) catch @panic("test failure");
3825 expect(vec[492] == false) catch @panic("test failure");
3826 expect(vec[493] == false) catch @panic("test failure");
3827 expect(vec[494] == false) catch @panic("test failure");
3828 expect(vec[495] == true) catch @panic("test failure");
3829 expect(vec[496] == true) catch @panic("test failure");
3830 expect(vec[497] == false) catch @panic("test failure");
3831 expect(vec[498] == false) catch @panic("test failure");
3832 expect(vec[499] == true) catch @panic("test failure");
3833 expect(vec[500] == false) catch @panic("test failure");
3834 expect(vec[501] == true) catch @panic("test failure");
3835 expect(vec[502] == false) catch @panic("test failure");
3836 expect(vec[503] == false) catch @panic("test failure");
3837 expect(vec[504] == false) catch @panic("test failure");
3838 expect(vec[505] == true) catch @panic("test failure");
3839 expect(vec[506] == true) catch @panic("test failure");
3840 expect(vec[507] == true) catch @panic("test failure");
3841 expect(vec[508] == true) catch @panic("test failure");
3842 expect(vec[509] == false) catch @panic("test failure");
3843 expect(vec[510] == false) catch @panic("test failure");
3844 expect(vec[511] == true) catch @panic("test failure");
3845 }
3846 };
3847 }
3848}
3849
3850extern fn c_ret_vector_512_bool() @Vector(512, bool);
3851extern fn c_vector_512_bool(@Vector(512, bool)) void;
3852extern fn c_test_vector_512_bool() void;
3853
3854test "@Vector(512, bool)" {
3855 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
3856 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
3857 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
3858 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
3859 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
3860 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
3861
3862 const vec = c_ret_vector_512_bool();
3863 try expect(vec[0] == false);
3864 try expect(vec[1] == true);
3865 try expect(vec[2] == false);
3866 try expect(vec[3] == false);
3867 try expect(vec[4] == false);
3868 try expect(vec[5] == true);
3869 try expect(vec[6] == false);
3870 try expect(vec[7] == false);
3871 try expect(vec[8] == false);
3872 try expect(vec[9] == true);
3873 try expect(vec[10] == false);
3874 try expect(vec[11] == false);
3875 try expect(vec[12] == false);
3876 try expect(vec[13] == true);
3877 try expect(vec[14] == false);
3878 try expect(vec[15] == true);
3879 try expect(vec[16] == false);
3880 try expect(vec[17] == false);
3881 try expect(vec[18] == false);
3882 try expect(vec[19] == false);
3883 try expect(vec[20] == false);
3884 try expect(vec[21] == false);
3885 try expect(vec[22] == true);
3886 try expect(vec[23] == true);
3887 try expect(vec[24] == false);
3888 try expect(vec[25] == false);
3889 try expect(vec[26] == false);
3890 try expect(vec[27] == false);
3891 try expect(vec[28] == true);
3892 try expect(vec[29] == true);
3893 try expect(vec[30] == false);
3894 try expect(vec[31] == true);
3895 try expect(vec[32] == false);
3896 try expect(vec[33] == true);
3897 try expect(vec[34] == true);
3898 try expect(vec[35] == true);
3899 try expect(vec[36] == false);
3900 try expect(vec[37] == false);
3901 try expect(vec[38] == true);
3902 try expect(vec[39] == true);
3903 try expect(vec[40] == false);
3904 try expect(vec[41] == false);
3905 try expect(vec[42] == false);
3906 try expect(vec[43] == false);
3907 try expect(vec[44] == false);
3908 try expect(vec[45] == true);
3909 try expect(vec[46] == false);
3910 try expect(vec[47] == true);
3911 try expect(vec[48] == true);
3912 try expect(vec[49] == false);
3913 try expect(vec[50] == true);
3914 try expect(vec[51] == true);
3915 try expect(vec[52] == true);
3916 try expect(vec[53] == true);
3917 try expect(vec[54] == false);
3918 try expect(vec[55] == false);
3919 try expect(vec[56] == false);
3920 try expect(vec[57] == true);
3921 try expect(vec[58] == true);
3922 try expect(vec[59] == false);
3923 try expect(vec[60] == false);
3924 try expect(vec[61] == false);
3925 try expect(vec[62] == false);
3926 try expect(vec[63] == true);
3927 try expect(vec[64] == true);
3928 try expect(vec[65] == true);
3929 try expect(vec[66] == true);
3930 try expect(vec[67] == true);
3931 try expect(vec[68] == false);
3932 try expect(vec[69] == false);
3933 try expect(vec[70] == false);
3934 try expect(vec[71] == false);
3935 try expect(vec[72] == false);
3936 try expect(vec[73] == true);
3937 try expect(vec[74] == false);
3938 try expect(vec[75] == true);
3939 try expect(vec[76] == false);
3940 try expect(vec[77] == false);
3941 try expect(vec[78] == true);
3942 try expect(vec[79] == true);
3943 try expect(vec[80] == false);
3944 try expect(vec[81] == false);
3945 try expect(vec[82] == false);
3946 try expect(vec[83] == true);
3947 try expect(vec[84] == false);
3948 try expect(vec[85] == true);
3949 try expect(vec[86] == true);
3950 try expect(vec[87] == true);
3951 try expect(vec[88] == false);
3952 try expect(vec[89] == true);
3953 try expect(vec[90] == false);
3954 try expect(vec[91] == false);
3955 try expect(vec[92] == true);
3956 try expect(vec[93] == true);
3957 try expect(vec[94] == false);
3958 try expect(vec[95] == true);
3959 try expect(vec[96] == true);
3960 try expect(vec[97] == false);
3961 try expect(vec[98] == true);
3962 try expect(vec[99] == false);
3963 try expect(vec[100] == true);
3964 try expect(vec[101] == true);
3965 try expect(vec[102] == false);
3966 try expect(vec[103] == true);
3967 try expect(vec[104] == true);
3968 try expect(vec[105] == false);
3969 try expect(vec[106] == false);
3970 try expect(vec[107] == false);
3971 try expect(vec[108] == true);
3972 try expect(vec[109] == false);
3973 try expect(vec[110] == false);
3974 try expect(vec[111] == false);
3975 try expect(vec[112] == true);
3976 try expect(vec[113] == true);
3977 try expect(vec[114] == true);
3978 try expect(vec[115] == false);
3979 try expect(vec[116] == true);
3980 try expect(vec[117] == false);
3981 try expect(vec[118] == true);
3982 try expect(vec[119] == false);
3983 try expect(vec[120] == true);
3984 try expect(vec[121] == true);
3985 try expect(vec[122] == false);
3986 try expect(vec[123] == true);
3987 try expect(vec[124] == false);
3988 try expect(vec[125] == true);
3989 try expect(vec[126] == true);
3990 try expect(vec[127] == true);
3991 try expect(vec[128] == false);
3992 try expect(vec[129] == true);
3993 try expect(vec[130] == false);
3994 try expect(vec[131] == false);
3995 try expect(vec[132] == false);
3996 try expect(vec[133] == false);
3997 try expect(vec[134] == false);
3998 try expect(vec[135] == false);
3999 try expect(vec[136] == true);
4000 try expect(vec[137] == false);
4001 try expect(vec[138] == true);
4002 try expect(vec[139] == false);
4003 try expect(vec[140] == true);
4004 try expect(vec[141] == true);
4005 try expect(vec[142] == false);
4006 try expect(vec[143] == true);
4007 try expect(vec[144] == false);
4008 try expect(vec[145] == false);
4009 try expect(vec[146] == true);
4010 try expect(vec[147] == false);
4011 try expect(vec[148] == false);
4012 try expect(vec[149] == true);
4013 try expect(vec[150] == false);
4014 try expect(vec[151] == true);
4015 try expect(vec[152] == false);
4016 try expect(vec[153] == true);
4017 try expect(vec[154] == false);
4018 try expect(vec[155] == false);
4019 try expect(vec[156] == true);
4020 try expect(vec[157] == false);
4021 try expect(vec[158] == true);
4022 try expect(vec[159] == true);
4023 try expect(vec[160] == true);
4024 try expect(vec[161] == false);
4025 try expect(vec[162] == false);
4026 try expect(vec[163] == true);
4027 try expect(vec[164] == false);
4028 try expect(vec[165] == false);
4029 try expect(vec[166] == false);
4030 try expect(vec[167] == true);
4031 try expect(vec[168] == true);
4032 try expect(vec[169] == true);
4033 try expect(vec[170] == false);
4034 try expect(vec[171] == true);
4035 try expect(vec[172] == false);
4036 try expect(vec[173] == false);
4037 try expect(vec[174] == false);
4038 try expect(vec[175] == false);
4039 try expect(vec[176] == false);
4040 try expect(vec[177] == true);
4041 try expect(vec[178] == true);
4042 try expect(vec[179] == false);
4043 try expect(vec[180] == false);
4044 try expect(vec[181] == true);
4045 try expect(vec[182] == false);
4046 try expect(vec[183] == false);
4047 try expect(vec[184] == false);
4048 try expect(vec[185] == false);
4049 try expect(vec[186] == false);
4050 try expect(vec[187] == true);
4051 try expect(vec[188] == true);
4052 try expect(vec[189] == false);
4053 try expect(vec[190] == false);
4054 try expect(vec[191] == false);
4055 try expect(vec[192] == false);
4056 try expect(vec[193] == false);
4057 try expect(vec[194] == false);
4058 try expect(vec[195] == true);
4059 try expect(vec[196] == true);
4060 try expect(vec[197] == false);
4061 try expect(vec[198] == true);
4062 try expect(vec[199] == true);
4063 try expect(vec[200] == true);
4064 try expect(vec[201] == true);
4065 try expect(vec[202] == true);
4066 try expect(vec[203] == true);
4067 try expect(vec[204] == false);
4068 try expect(vec[205] == false);
4069 try expect(vec[206] == false);
4070 try expect(vec[207] == false);
4071 try expect(vec[208] == true);
4072 try expect(vec[209] == false);
4073 try expect(vec[210] == true);
4074 try expect(vec[211] == true);
4075 try expect(vec[212] == true);
4076 try expect(vec[213] == true);
4077 try expect(vec[214] == false);
4078 try expect(vec[215] == false);
4079 try expect(vec[216] == false);
4080 try expect(vec[217] == true);
4081 try expect(vec[218] == true);
4082 try expect(vec[219] == false);
4083 try expect(vec[220] == true);
4084 try expect(vec[221] == true);
4085 try expect(vec[222] == false);
4086 try expect(vec[223] == false);
4087 try expect(vec[224] == false);
4088 try expect(vec[225] == true);
4089 try expect(vec[226] == true);
4090 try expect(vec[227] == true);
4091 try expect(vec[228] == true);
4092 try expect(vec[229] == false);
4093 try expect(vec[230] == true);
4094 try expect(vec[231] == false);
4095 try expect(vec[232] == true);
4096 try expect(vec[233] == true);
4097 try expect(vec[234] == true);
4098 try expect(vec[235] == true);
4099 try expect(vec[236] == false);
4100 try expect(vec[237] == true);
4101 try expect(vec[238] == false);
4102 try expect(vec[239] == true);
4103 try expect(vec[240] == false);
4104 try expect(vec[241] == true);
4105 try expect(vec[242] == false);
4106 try expect(vec[243] == false);
4107 try expect(vec[244] == false);
4108 try expect(vec[245] == true);
4109 try expect(vec[246] == true);
4110 try expect(vec[247] == false);
4111 try expect(vec[248] == true);
4112 try expect(vec[249] == false);
4113 try expect(vec[250] == false);
4114 try expect(vec[251] == false);
4115 try expect(vec[252] == true);
4116 try expect(vec[253] == true);
4117 try expect(vec[254] == true);
4118 try expect(vec[255] == true);
4119 try expect(vec[256] == true);
4120 try expect(vec[257] == false);
4121 try expect(vec[258] == true);
4122 try expect(vec[259] == true);
4123 try expect(vec[260] == true);
4124 try expect(vec[261] == true);
4125 try expect(vec[262] == false);
4126 try expect(vec[263] == true);
4127 try expect(vec[264] == false);
4128 try expect(vec[265] == false);
4129 try expect(vec[266] == true);
4130 try expect(vec[267] == false);
4131 try expect(vec[268] == true);
4132 try expect(vec[269] == false);
4133 try expect(vec[270] == false);
4134 try expect(vec[271] == true);
4135 try expect(vec[272] == true);
4136 try expect(vec[273] == false);
4137 try expect(vec[274] == true);
4138 try expect(vec[275] == false);
4139 try expect(vec[276] == false);
4140 try expect(vec[277] == true);
4141 try expect(vec[278] == false);
4142 try expect(vec[279] == false);
4143 try expect(vec[280] == true);
4144 try expect(vec[281] == true);
4145 try expect(vec[282] == true);
4146 try expect(vec[283] == false);
4147 try expect(vec[284] == false);
4148 try expect(vec[285] == true);
4149 try expect(vec[286] == true);
4150 try expect(vec[287] == true);
4151 try expect(vec[288] == false);
4152 try expect(vec[289] == false);
4153 try expect(vec[290] == false);
4154 try expect(vec[291] == false);
4155 try expect(vec[292] == false);
4156 try expect(vec[293] == false);
4157 try expect(vec[294] == true);
4158 try expect(vec[295] == false);
4159 try expect(vec[296] == true);
4160 try expect(vec[297] == false);
4161 try expect(vec[298] == true);
4162 try expect(vec[299] == true);
4163 try expect(vec[300] == false);
4164 try expect(vec[301] == false);
4165 try expect(vec[302] == false);
4166 try expect(vec[303] == false);
4167 try expect(vec[304] == true);
4168 try expect(vec[305] == true);
4169 try expect(vec[306] == true);
4170 try expect(vec[307] == true);
4171 try expect(vec[308] == true);
4172 try expect(vec[309] == false);
4173 try expect(vec[310] == true);
4174 try expect(vec[311] == true);
4175 try expect(vec[312] == true);
4176 try expect(vec[313] == true);
4177 try expect(vec[314] == true);
4178 try expect(vec[315] == false);
4179 try expect(vec[316] == true);
4180 try expect(vec[317] == true);
4181 try expect(vec[318] == true);
4182 try expect(vec[319] == false);
4183 try expect(vec[320] == true);
4184 try expect(vec[321] == false);
4185 try expect(vec[322] == true);
4186 try expect(vec[323] == true);
4187 try expect(vec[324] == true);
4188 try expect(vec[325] == false);
4189 try expect(vec[326] == false);
4190 try expect(vec[327] == true);
4191 try expect(vec[328] == true);
4192 try expect(vec[329] == true);
4193 try expect(vec[330] == false);
4194 try expect(vec[331] == false);
4195 try expect(vec[332] == true);
4196 try expect(vec[333] == true);
4197 try expect(vec[334] == false);
4198 try expect(vec[335] == true);
4199 try expect(vec[336] == true);
4200 try expect(vec[337] == true);
4201 try expect(vec[338] == true);
4202 try expect(vec[339] == true);
4203 try expect(vec[340] == true);
4204 try expect(vec[341] == false);
4205 try expect(vec[342] == true);
4206 try expect(vec[343] == false);
4207 try expect(vec[344] == true);
4208 try expect(vec[345] == false);
4209 try expect(vec[346] == false);
4210 try expect(vec[347] == false);
4211 try expect(vec[348] == false);
4212 try expect(vec[349] == true);
4213 try expect(vec[350] == true);
4214 try expect(vec[351] == true);
4215 try expect(vec[352] == true);
4216 try expect(vec[353] == false);
4217 try expect(vec[354] == true);
4218 try expect(vec[355] == false);
4219 try expect(vec[356] == true);
4220 try expect(vec[357] == true);
4221 try expect(vec[358] == false);
4222 try expect(vec[359] == true);
4223 try expect(vec[360] == false);
4224 try expect(vec[361] == false);
4225 try expect(vec[362] == true);
4226 try expect(vec[363] == false);
4227 try expect(vec[364] == false);
4228 try expect(vec[365] == false);
4229 try expect(vec[366] == false);
4230 try expect(vec[367] == false);
4231 try expect(vec[368] == false);
4232 try expect(vec[369] == false);
4233 try expect(vec[370] == true);
4234 try expect(vec[371] == false);
4235 try expect(vec[372] == true);
4236 try expect(vec[373] == true);
4237 try expect(vec[374] == false);
4238 try expect(vec[375] == false);
4239 try expect(vec[376] == true);
4240 try expect(vec[377] == false);
4241 try expect(vec[378] == false);
4242 try expect(vec[379] == true);
4243 try expect(vec[380] == false);
4244 try expect(vec[381] == false);
4245 try expect(vec[382] == true);
4246 try expect(vec[383] == false);
4247 try expect(vec[384] == false);
4248 try expect(vec[385] == false);
4249 try expect(vec[386] == false);
4250 try expect(vec[387] == true);
4251 try expect(vec[388] == true);
4252 try expect(vec[389] == true);
4253 try expect(vec[390] == true);
4254 try expect(vec[391] == true);
4255 try expect(vec[392] == true);
4256 try expect(vec[393] == true);
4257 try expect(vec[394] == false);
4258 try expect(vec[395] == true);
4259 try expect(vec[396] == true);
4260 try expect(vec[397] == false);
4261 try expect(vec[398] == false);
4262 try expect(vec[399] == false);
4263 try expect(vec[400] == true);
4264 try expect(vec[401] == false);
4265 try expect(vec[402] == true);
4266 try expect(vec[403] == true);
4267 try expect(vec[404] == false);
4268 try expect(vec[405] == true);
4269 try expect(vec[406] == true);
4270 try expect(vec[407] == true);
4271 try expect(vec[408] == true);
4272 try expect(vec[409] == false);
4273 try expect(vec[410] == false);
4274 try expect(vec[411] == false);
4275 try expect(vec[412] == true);
4276 try expect(vec[413] == true);
4277 try expect(vec[414] == false);
4278 try expect(vec[415] == true);
4279 try expect(vec[416] == false);
4280 try expect(vec[417] == true);
4281 try expect(vec[418] == false);
4282 try expect(vec[419] == false);
4283 try expect(vec[420] == false);
4284 try expect(vec[421] == false);
4285 try expect(vec[422] == true);
4286 try expect(vec[423] == true);
4287 try expect(vec[424] == true);
4288 try expect(vec[425] == false);
4289 try expect(vec[426] == true);
4290 try expect(vec[427] == false);
4291 try expect(vec[428] == false);
4292 try expect(vec[429] == false);
4293 try expect(vec[430] == true);
4294 try expect(vec[431] == true);
4295 try expect(vec[432] == false);
4296 try expect(vec[433] == true);
4297 try expect(vec[434] == false);
4298 try expect(vec[435] == false);
4299 try expect(vec[436] == true);
4300 try expect(vec[437] == true);
4301 try expect(vec[438] == true);
4302 try expect(vec[439] == true);
4303 try expect(vec[440] == true);
4304 try expect(vec[441] == true);
4305 try expect(vec[442] == false);
4306 try expect(vec[443] == false);
4307 try expect(vec[444] == false);
4308 try expect(vec[445] == true);
4309 try expect(vec[446] == true);
4310 try expect(vec[447] == true);
4311 try expect(vec[448] == false);
4312 try expect(vec[449] == false);
4313 try expect(vec[450] == false);
4314 try expect(vec[451] == false);
4315 try expect(vec[452] == false);
4316 try expect(vec[453] == false);
4317 try expect(vec[454] == false);
4318 try expect(vec[455] == false);
4319 try expect(vec[456] == false);
4320 try expect(vec[457] == false);
4321 try expect(vec[458] == false);
4322 try expect(vec[459] == true);
4323 try expect(vec[460] == false);
4324 try expect(vec[461] == false);
4325 try expect(vec[462] == false);
4326 try expect(vec[463] == true);
4327 try expect(vec[464] == false);
4328 try expect(vec[465] == false);
4329 try expect(vec[466] == false);
4330 try expect(vec[467] == false);
4331 try expect(vec[468] == true);
4332 try expect(vec[469] == true);
4333 try expect(vec[470] == true);
4334 try expect(vec[471] == true);
4335 try expect(vec[472] == true);
4336 try expect(vec[473] == false);
4337 try expect(vec[474] == false);
4338 try expect(vec[475] == true);
4339 try expect(vec[476] == true);
4340 try expect(vec[477] == true);
4341 try expect(vec[478] == false);
4342 try expect(vec[479] == true);
4343 try expect(vec[480] == true);
4344 try expect(vec[481] == true);
4345 try expect(vec[482] == false);
4346 try expect(vec[483] == true);
4347 try expect(vec[484] == false);
4348 try expect(vec[485] == true);
4349 try expect(vec[486] == false);
4350 try expect(vec[487] == true);
4351 try expect(vec[488] == false);
4352 try expect(vec[489] == true);
4353 try expect(vec[490] == true);
4354 try expect(vec[491] == true);
4355 try expect(vec[492] == true);
4356 try expect(vec[493] == false);
4357 try expect(vec[494] == true);
4358 try expect(vec[495] == true);
4359 try expect(vec[496] == false);
4360 try expect(vec[497] == true);
4361 try expect(vec[498] == false);
4362 try expect(vec[499] == false);
4363 try expect(vec[500] == false);
4364 try expect(vec[501] == false);
4365 try expect(vec[502] == false);
4366 try expect(vec[503] == false);
4367 try expect(vec[504] == false);
4368 try expect(vec[505] == false);
4369 try expect(vec[506] == false);
4370 try expect(vec[507] == true);
4371 try expect(vec[508] == true);
4372 try expect(vec[509] == false);
4373 try expect(vec[510] == true);
4374 try expect(vec[511] == false);
4375 if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{
4376 true,
4377 true,
4378 true,
4379 true,
4380 true,
4381 false,
4382 false,
4383 true,
4384 true,
4385 true,
4386 true,
4387 false,
4388 true,
4389 true,
4390 false,
4391 false,
4392 false,
4393 true,
4394 true,
4395 true,
4396 true,
4397 true,
4398 false,
4399 false,
4400 true,
4401 true,
4402 false,
4403 false,
4404 false,
4405 false,
4406 false,
4407 true,
4408 true,
4409 false,
4410 true,
4411 true,
4412 true,
4413 true,
4414 true,
4415 true,
4416 false,
4417 true,
4418 true,
4419 false,
4420 false,
4421 false,
4422 true,
4423 true,
4424 false,
4425 true,
4426 false,
4427 true,
4428 true,
4429 false,
4430 true,
4431 false,
4432 false,
4433 true,
4434 true,
4435 false,
4436 true,
4437 true,
4438 false,
4439 true,
4440 false,
4441 true,
4442 true,
4443 true,
4444 true,
4445 true,
4446 true,
4447 true,
4448 true,
4449 true,
4450 false,
4451 true,
4452 false,
4453 true,
4454 false,
4455 false,
4456 false,
4457 true,
4458 false,
4459 true,
4460 true,
4461 false,
4462 true,
4463 true,
4464 true,
4465 false,
4466 true,
4467 true,
4468 false,
4469 true,
4470 false,
4471 true,
4472 true,
4473 false,
4474 false,
4475 false,
4476 true,
4477 true,
4478 false,
4479 true,
4480 false,
4481 false,
4482 true,
4483 false,
4484 false,
4485 true,
4486 false,
4487 false,
4488 false,
4489 false,
4490 false,
4491 true,
4492 true,
4493 false,
4494 false,
4495 false,
4496 false,
4497 true,
4498 false,
4499 false,
4500 true,
4501 true,
4502 false,
4503 true,
4504 false,
4505 true,
4506 true,
4507 false,
4508 true,
4509 false,
4510 false,
4511 false,
4512 false,
4513 true,
4514 true,
4515 false,
4516 false,
4517 false,
4518 true,
4519 true,
4520 false,
4521 false,
4522 true,
4523 true,
4524 true,
4525 true,
4526 true,
4527 true,
4528 true,
4529 false,
4530 true,
4531 false,
4532 false,
4533 true,
4534 false,
4535 true,
4536 false,
4537 true,
4538 true,
4539 true,
4540 true,
4541 true,
4542 true,
4543 true,
4544 true,
4545 false,
4546 true,
4547 true,
4548 false,
4549 true,
4550 true,
4551 false,
4552 false,
4553 false,
4554 true,
4555 false,
4556 false,
4557 true,
4558 true,
4559 true,
4560 true,
4561 true,
4562 true,
4563 true,
4564 true,
4565 true,
4566 false,
4567 true,
4568 true,
4569 false,
4570 false,
4571 true,
4572 true,
4573 false,
4574 true,
4575 true,
4576 false,
4577 true,
4578 true,
4579 false,
4580 true,
4581 true,
4582 true,
4583 true,
4584 false,
4585 true,
4586 false,
4587 true,
4588 true,
4589 false,
4590 true,
4591 false,
4592 true,
4593 false,
4594 true,
4595 false,
4596 false,
4597 true,
4598 false,
4599 false,
4600 false,
4601 true,
4602 true,
4603 false,
4604 false,
4605 false,
4606 true,
4607 false,
4608 true,
4609 false,
4610 false,
4611 false,
4612 true,
4613 true,
4614 false,
4615 false,
4616 false,
4617 false,
4618 false,
4619 true,
4620 true,
4621 false,
4622 true,
4623 false,
4624 false,
4625 true,
4626 false,
4627 false,
4628 false,
4629 true,
4630 false,
4631 false,
4632 false,
4633 false,
4634 true,
4635 true,
4636 true,
4637 true,
4638 false,
4639 true,
4640 false,
4641 false,
4642 false,
4643 true,
4644 false,
4645 false,
4646 true,
4647 true,
4648 false,
4649 false,
4650 false,
4651 false,
4652 false,
4653 true,
4654 false,
4655 true,
4656 true,
4657 true,
4658 true,
4659 true,
4660 false,
4661 false,
4662 false,
4663 false,
4664 false,
4665 false,
4666 false,
4667 false,
4668 false,
4669 true,
4670 true,
4671 true,
4672 true,
4673 true,
4674 true,
4675 false,
4676 true,
4677 false,
4678 true,
4679 true,
4680 true,
4681 false,
4682 false,
4683 true,
4684 true,
4685 true,
4686 false,
4687 true,
4688 true,
4689 true,
4690 false,
4691 true,
4692 true,
4693 true,
4694 false,
4695 true,
4696 true,
4697 false,
4698 false,
4699 true,
4700 false,
4701 false,
4702 false,
4703 false,
4704 true,
4705 false,
4706 true,
4707 true,
4708 true,
4709 true,
4710 false,
4711 false,
4712 true,
4713 false,
4714 true,
4715 false,
4716 false,
4717 false,
4718 true,
4719 false,
4720 true,
4721 false,
4722 false,
4723 true,
4724 true,
4725 true,
4726 true,
4727 false,
4728 false,
4729 false,
4730 true,
4731 true,
4732 false,
4733 true,
4734 false,
4735 false,
4736 true,
4737 false,
4738 true,
4739 false,
4740 true,
4741 true,
4742 false,
4743 false,
4744 true,
4745 true,
4746 true,
4747 true,
4748 false,
4749 false,
4750 true,
4751 false,
4752 true,
4753 true,
4754 false,
4755 true,
4756 true,
4757 false,
4758 true,
4759 true,
4760 true,
4761 false,
4762 true,
4763 true,
4764 true,
4765 false,
4766 false,
4767 true,
4768 false,
4769 true,
4770 true,
4771 true,
4772 false,
4773 false,
4774 false,
4775 false,
4776 false,
4777 true,
4778 false,
4779 false,
4780 false,
4781 false,
4782 true,
4783 false,
4784 false,
4785 true,
4786 true,
4787 false,
4788 false,
4789 false,
4790 false,
4791 true,
4792 true,
4793 true,
4794 true,
4795 true,
4796 false,
4797 false,
4798 false,
4799 true,
4800 false,
4801 false,
4802 false,
4803 false,
4804 true,
4805 false,
4806 true,
4807 false,
4808 true,
4809 true,
4810 true,
4811 true,
4812 false,
4813 false,
4814 false,
4815 false,
4816 false,
4817 true,
4818 true,
4819 true,
4820 true,
4821 true,
4822 true,
4823 true,
4824 true,
4825 true,
4826 false,
4827 false,
4828 true,
4829 false,
4830 true,
4831 false,
4832 false,
4833 true,
4834 false,
4835 false,
4836 true,
4837 true,
4838 true,
4839 true,
4840 true,
4841 true,
4842 false,
4843 true,
4844 false,
4845 false,
4846 false,
4847 true,
4848 true,
4849 false,
4850 true,
4851 true,
4852 false,
4853 false,
4854 true,
4855 true,
4856 false,
4857 false,
4858 true,
4859 true,
4860 false,
4861 true,
4862 false,
4863 true,
4864 true,
4865 true,
4866 true,
4867 true,
4868 true,
4869 true,
4870 true,
4871 true,
4872 false,
4873 true,
4874 true,
4875 true,
4876 false,
4877 false,
4878 true,
4879 false,
4880 false,
4881 false,
4882 true,
4883 true,
4884 false,
4885 true,
4886 false,
4887 true,
4888 });
4889 c_test_vector_512_bool();
4890}
4891
4892export fn zig_ret_vector_1_u8() @Vector(1, u8) {
4893 return .{1};
4894}
4895export fn zig_vector_1_u8(v: @Vector(1, u8), i: usize) void {
4896 expect(v[0] == 2) catch @panic("test failure");
4897 expect(i == 1) catch @panic("test failure");
4898}
4899
4900extern fn c_ret_vector_1_u8() @Vector(1, u8);
4901extern fn c_vector_1_u8(@Vector(1, u8), usize) void;
4902extern fn c_test_vector_1_u8() void;
4903
4904test "@Vector(1, u8)" {
4905 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
4906 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
4907 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
4908
4909 const v = c_ret_vector_1_u8();
4910 try expect(v[0] == 3);
4911 c_vector_1_u8(.{4}, 1);
4912 c_test_vector_1_u8();
4913}
4914
4915export fn zig_ret_vector_2_u8() @Vector(2, u8) {
4916 return .{ 5, 6 };
4917}
4918export fn zig_vector_2_u8(v: @Vector(2, u8), i: usize) void {
4919 expect(v[0] == 7) catch @panic("test failure");
4920 expect(v[1] == 8) catch @panic("test failure");
4921 expect(i == 2) catch @panic("test failure");
4922}
4923
4924extern fn c_ret_vector_2_u8() @Vector(2, u8);
4925extern fn c_vector_2_u8(@Vector(2, u8), usize) void;
4926extern fn c_test_vector_2_u8() void;
4927
4928test "@Vector(2, u8)" {
4929 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
4930 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
4931 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
4932 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
4933 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
4934 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
4935
4936 const v = c_ret_vector_2_u8();
4937 try expect(v[0] == 9);
4938 try expect(v[1] == 10);
4939 c_vector_2_u8(.{ 11, 12 }, 2);
4940 c_test_vector_2_u8();
4941}
4942
4943export fn zig_ret_vector_3_u8() @Vector(3, u8) {
4944 return .{ 13, 14, 15 };
4945}
4946export fn zig_vector_3_u8(v: @Vector(3, u8), i: usize) void {
4947 expect(v[0] == 16) catch @panic("test failure");
4948 expect(v[1] == 17) catch @panic("test failure");
4949 expect(v[2] == 18) catch @panic("test failure");
4950 expect(i == 3) catch @panic("test failure");
4951}
4952
4953extern fn c_ret_vector_3_u8() @Vector(3, u8);
4954extern fn c_vector_3_u8(@Vector(3, u8), usize) void;
4955extern fn c_test_vector_3_u8() void;
4956
4957test "@Vector(3, u8)" {
4958 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
4959 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
4960 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
4961 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
4962 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
4963
4964 const v = c_ret_vector_3_u8();
4965 try expect(v[0] == 19);
4966 try expect(v[1] == 20);
4967 try expect(v[2] == 21);
4968 c_vector_3_u8(.{ 22, 23, 24 }, 3);
4969 c_test_vector_3_u8();
4970}
4971
4972export fn zig_ret_vector_4_u8() @Vector(4, u8) {
4973 return .{ 25, 26, 27, 28 };
4974}
4975export fn zig_vector_4_u8(v: @Vector(4, u8), i: usize) void {
4976 expect(v[0] == 29) catch @panic("test failure");
4977 expect(v[1] == 30) catch @panic("test failure");
4978 expect(v[2] == 31) catch @panic("test failure");
4979 expect(v[3] == 32) catch @panic("test failure");
4980 expect(i == 4) catch @panic("test failure");
4981}
4982export fn zig_vector_4_u8_vector_4_u8(v0: @Vector(4, u8), v1: @Vector(4, u8), i: usize) void {
4983 expect(v0[0] == 33) catch @panic("test failure");
4984 expect(v0[1] == 34) catch @panic("test failure");
4985 expect(v0[2] == 35) catch @panic("test failure");
4986 expect(v0[3] == 36) catch @panic("test failure");
4987 expect(v1[0] == 37) catch @panic("test failure");
4988 expect(v1[1] == 38) catch @panic("test failure");
4989 expect(v1[2] == 39) catch @panic("test failure");
4990 expect(v1[3] == 40) catch @panic("test failure");
4991 expect(i == 8) catch @panic("test failure");
4992}
4993
4994extern fn c_ret_vector_4_u8() @Vector(4, u8);
4995extern fn c_vector_4_u8(@Vector(4, u8), usize) void;
4996extern fn c_vector_4_u8_vector_4_u8(@Vector(4, u8), @Vector(4, u8), usize) void;
4997extern fn c_test_vector_4_u8() void;
4998
4999test "@Vector(4, u8)" {
5000 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
5001 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5002 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5003 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5004 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5005 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
5006
5007 const v = c_ret_vector_4_u8();
5008 try expect(v[0] == 41);
5009 try expect(v[1] == 42);
5010 try expect(v[2] == 43);
5011 try expect(v[3] == 44);
5012 c_vector_4_u8(.{ 45, 46, 47, 48 }, 4);
5013 c_vector_4_u8_vector_4_u8(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
5014 c_test_vector_4_u8();
5015}
5016
5017export fn zig_ret_vector_6_u8() @Vector(6, u8) {
5018 return .{ 41, 42, 43, 44, 45, 46 };
5019}
5020export fn zig_vector_6_u8(v: @Vector(6, u8), i: usize) void {
5021 expect(v[0] == 47) catch @panic("test failure");
5022 expect(v[1] == 48) catch @panic("test failure");
5023 expect(v[2] == 49) catch @panic("test failure");
5024 expect(v[3] == 50) catch @panic("test failure");
5025 expect(v[4] == 51) catch @panic("test failure");
5026 expect(v[5] == 52) catch @panic("test failure");
5027 expect(i == 6) catch @panic("test failure");
5028}
5029
5030extern fn c_ret_vector_6_u8() @Vector(6, u8);
5031extern fn c_vector_6_u8(@Vector(6, u8), usize) void;
5032extern fn c_test_vector_6_u8() void;
5033
5034test "@Vector(6, u8)" {
5035 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
5036 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5037 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
5038 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5039
5040 const v = c_ret_vector_6_u8();
5041 try expect(v[0] == 53);
5042 try expect(v[1] == 54);
5043 try expect(v[2] == 55);
5044 try expect(v[3] == 56);
5045 try expect(v[4] == 57);
5046 try expect(v[5] == 58);
5047 c_vector_6_u8(.{ 59, 60, 61, 62, 63, 64 }, 6);
5048 c_test_vector_6_u8();
5049}
5050
5051export fn zig_ret_vector_8_u8() @Vector(8, u8) {
5052 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
5053}
5054export fn zig_vector_8_u8(v: @Vector(8, u8), i: usize) void {
5055 expect(v[0] == 73) catch @panic("test failure");
5056 expect(v[1] == 74) catch @panic("test failure");
5057 expect(v[2] == 75) catch @panic("test failure");
5058 expect(v[3] == 76) catch @panic("test failure");
5059 expect(v[4] == 77) catch @panic("test failure");
5060 expect(v[5] == 78) catch @panic("test failure");
5061 expect(v[6] == 79) catch @panic("test failure");
5062 expect(v[7] == 80) catch @panic("test failure");
5063 expect(i == 8) catch @panic("test failure");
5064}
5065
5066extern fn c_ret_vector_8_u8() @Vector(8, u8);
5067extern fn c_vector_8_u8(@Vector(8, u8), usize) void;
5068extern fn c_test_vector_8_u8() void;
5069
5070test "@Vector(8, u8)" {
5071 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5072 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5073 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
5074 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
5075
5076 const v = c_ret_vector_8_u8();
5077 try expect(v[0] == 81);
5078 try expect(v[1] == 82);
5079 try expect(v[2] == 83);
5080 try expect(v[3] == 84);
5081 try expect(v[4] == 85);
5082 try expect(v[5] == 86);
5083 try expect(v[6] == 87);
5084 try expect(v[7] == 88);
5085 c_vector_8_u8(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
5086 c_test_vector_8_u8();
5087}
5088
5089export fn zig_ret_vector_12_u8() @Vector(12, u8) {
5090 return .{ 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
5091}
5092export fn zig_vector_12_u8(v: @Vector(12, u8), i: usize) void {
5093 expect(v[0] == 9) catch @panic("test failure");
5094 expect(v[1] == 10) catch @panic("test failure");
5095 expect(v[2] == 11) catch @panic("test failure");
5096 expect(v[3] == 12) catch @panic("test failure");
5097 expect(v[4] == 13) catch @panic("test failure");
5098 expect(v[5] == 14) catch @panic("test failure");
5099 expect(v[6] == 15) catch @panic("test failure");
5100 expect(v[7] == 16) catch @panic("test failure");
5101 expect(v[8] == 17) catch @panic("test failure");
5102 expect(v[9] == 18) catch @panic("test failure");
5103 expect(v[10] == 19) catch @panic("test failure");
5104 expect(v[11] == 20) catch @panic("test failure");
5105 expect(i == 12) catch @panic("test failure");
5106}
5107
5108extern fn c_ret_vector_12_u8() @Vector(12, u8);
5109extern fn c_vector_12_u8(@Vector(12, u8), usize) void;
5110extern fn c_test_vector_12_u8() void;
5111
5112test "@Vector(12, u8)" {
5113 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
5114 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5115 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
5116
5117 const v = c_ret_vector_12_u8();
5118 try expect(v[0] == 21);
5119 try expect(v[1] == 22);
5120 try expect(v[2] == 23);
5121 try expect(v[3] == 24);
5122 try expect(v[4] == 25);
5123 try expect(v[5] == 26);
5124 try expect(v[6] == 27);
5125 try expect(v[7] == 28);
5126 try expect(v[8] == 29);
5127 try expect(v[9] == 30);
5128 try expect(v[10] == 31);
5129 try expect(v[11] == 32);
5130 c_vector_12_u8(.{ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44 }, 12);
5131 c_test_vector_12_u8();
5132}
5133
5134export fn zig_ret_vector_16_u8() @Vector(16, u8) {
5135 return .{ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 };
5136}
5137export fn zig_vector_16_u8(v: @Vector(16, u8), i: usize) void {
5138 expect(v[0] == 61) catch @panic("test failure");
5139 expect(v[1] == 62) catch @panic("test failure");
5140 expect(v[2] == 63) catch @panic("test failure");
5141 expect(v[3] == 64) catch @panic("test failure");
5142 expect(v[4] == 65) catch @panic("test failure");
5143 expect(v[5] == 66) catch @panic("test failure");
5144 expect(v[6] == 67) catch @panic("test failure");
5145 expect(v[7] == 68) catch @panic("test failure");
5146 expect(v[8] == 69) catch @panic("test failure");
5147 expect(v[9] == 70) catch @panic("test failure");
5148 expect(v[10] == 71) catch @panic("test failure");
5149 expect(v[11] == 72) catch @panic("test failure");
5150 expect(v[12] == 73) catch @panic("test failure");
5151 expect(v[13] == 74) catch @panic("test failure");
5152 expect(v[14] == 75) catch @panic("test failure");
5153 expect(v[15] == 76) catch @panic("test failure");
5154 expect(i == 16) catch @panic("test failure");
5155}
5156
5157extern fn c_ret_vector_16_u8() @Vector(16, u8);
5158extern fn c_vector_16_u8(@Vector(16, u8), usize) void;
5159extern fn c_test_vector_16_u8() void;
5160
5161test "@Vector(16, u8)" {
5162 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5163
5164 const v = c_ret_vector_16_u8();
5165 try expect(v[0] == 77);
5166 try expect(v[1] == 78);
5167 try expect(v[2] == 79);
5168 try expect(v[3] == 80);
5169 try expect(v[4] == 81);
5170 try expect(v[5] == 82);
5171 try expect(v[6] == 83);
5172 try expect(v[7] == 84);
5173 try expect(v[8] == 85);
5174 try expect(v[9] == 86);
5175 try expect(v[10] == 87);
5176 try expect(v[11] == 88);
5177 try expect(v[12] == 89);
5178 try expect(v[13] == 90);
5179 try expect(v[14] == 91);
5180 try expect(v[15] == 92);
5181 c_vector_16_u8(.{ 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 }, 16);
5182 c_test_vector_16_u8();
5183}
5184
5185export fn zig_ret_vector_24_u8() @Vector(24, u8) {
5186 return .{
5187 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
5188 25, 26, 27, 28, 29, 30, 31, 32,
5189 };
5190}
5191export fn zig_vector_24_u8(v: @Vector(24, u8), i: usize) void {
5192 expect(v[0] == 33) catch @panic("test failure");
5193 expect(v[1] == 34) catch @panic("test failure");
5194 expect(v[2] == 35) catch @panic("test failure");
5195 expect(v[3] == 36) catch @panic("test failure");
5196 expect(v[4] == 37) catch @panic("test failure");
5197 expect(v[5] == 38) catch @panic("test failure");
5198 expect(v[6] == 39) catch @panic("test failure");
5199 expect(v[7] == 40) catch @panic("test failure");
5200 expect(v[8] == 41) catch @panic("test failure");
5201 expect(v[9] == 42) catch @panic("test failure");
5202 expect(v[10] == 43) catch @panic("test failure");
5203 expect(v[11] == 44) catch @panic("test failure");
5204 expect(v[12] == 45) catch @panic("test failure");
5205 expect(v[13] == 46) catch @panic("test failure");
5206 expect(v[14] == 47) catch @panic("test failure");
5207 expect(v[15] == 48) catch @panic("test failure");
5208 expect(v[16] == 49) catch @panic("test failure");
5209 expect(v[17] == 50) catch @panic("test failure");
5210 expect(v[18] == 51) catch @panic("test failure");
5211 expect(v[19] == 52) catch @panic("test failure");
5212 expect(v[20] == 53) catch @panic("test failure");
5213 expect(v[21] == 54) catch @panic("test failure");
5214 expect(v[22] == 55) catch @panic("test failure");
5215 expect(v[23] == 56) catch @panic("test failure");
5216 expect(i == 24) catch @panic("test failure");
5217}
5218
5219extern fn c_ret_vector_24_u8() @Vector(24, u8);
5220extern fn c_vector_24_u8(@Vector(24, u8), usize) void;
5221extern fn c_test_vector_24_u8() void;
5222
5223test "@Vector(24, u8)" {
5224 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5225 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5226 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
5227 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5228
5229 const v = c_ret_vector_24_u8();
5230 try expect(v[0] == 57);
5231 try expect(v[1] == 58);
5232 try expect(v[2] == 59);
5233 try expect(v[3] == 60);
5234 try expect(v[4] == 61);
5235 try expect(v[5] == 62);
5236 try expect(v[6] == 63);
5237 try expect(v[7] == 64);
5238 try expect(v[8] == 65);
5239 try expect(v[9] == 66);
5240 try expect(v[10] == 67);
5241 try expect(v[11] == 68);
5242 try expect(v[12] == 69);
5243 try expect(v[13] == 70);
5244 try expect(v[14] == 71);
5245 try expect(v[15] == 72);
5246 try expect(v[16] == 73);
5247 try expect(v[17] == 74);
5248 try expect(v[18] == 75);
5249 try expect(v[19] == 76);
5250 try expect(v[20] == 77);
5251 try expect(v[21] == 78);
5252 try expect(v[22] == 79);
5253 try expect(v[23] == 80);
5254 c_vector_24_u8(.{
5255 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
5256 97, 98, 99, 0, 1, 2, 3, 4,
5257 }, 24);
5258 c_test_vector_24_u8();
5259}
5260
5261export fn zig_ret_vector_32_u8() @Vector(32, u8) {
5262 return .{
5263 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
5264 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
5265 };
5266}
5267export fn zig_vector_32_u8(v: @Vector(32, u8), i: usize) void {
5268 expect(v[0] == 37) catch @panic("test failure");
5269 expect(v[1] == 38) catch @panic("test failure");
5270 expect(v[2] == 39) catch @panic("test failure");
5271 expect(v[3] == 40) catch @panic("test failure");
5272 expect(v[4] == 41) catch @panic("test failure");
5273 expect(v[5] == 42) catch @panic("test failure");
5274 expect(v[6] == 43) catch @panic("test failure");
5275 expect(v[7] == 44) catch @panic("test failure");
5276 expect(v[8] == 45) catch @panic("test failure");
5277 expect(v[9] == 46) catch @panic("test failure");
5278 expect(v[10] == 47) catch @panic("test failure");
5279 expect(v[11] == 48) catch @panic("test failure");
5280 expect(v[12] == 49) catch @panic("test failure");
5281 expect(v[13] == 50) catch @panic("test failure");
5282 expect(v[14] == 51) catch @panic("test failure");
5283 expect(v[15] == 52) catch @panic("test failure");
5284 expect(v[16] == 53) catch @panic("test failure");
5285 expect(v[17] == 54) catch @panic("test failure");
5286 expect(v[18] == 55) catch @panic("test failure");
5287 expect(v[19] == 56) catch @panic("test failure");
5288 expect(v[20] == 57) catch @panic("test failure");
5289 expect(v[21] == 58) catch @panic("test failure");
5290 expect(v[22] == 59) catch @panic("test failure");
5291 expect(v[23] == 60) catch @panic("test failure");
5292 expect(v[24] == 61) catch @panic("test failure");
5293 expect(v[25] == 62) catch @panic("test failure");
5294 expect(v[26] == 63) catch @panic("test failure");
5295 expect(v[27] == 64) catch @panic("test failure");
5296 expect(v[28] == 65) catch @panic("test failure");
5297 expect(v[29] == 66) catch @panic("test failure");
5298 expect(v[30] == 67) catch @panic("test failure");
5299 expect(v[31] == 68) catch @panic("test failure");
5300 expect(i == 32) catch @panic("test failure");
5301}
5302
5303extern fn c_ret_vector_32_u8() @Vector(32, u8);
5304extern fn c_vector_32_u8(@Vector(32, u8), usize) void;
5305extern fn c_test_vector_32_u8() void;
5306
5307test "@Vector(32, u8)" {
5308 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5309 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5310 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5311
5312 const v = c_ret_vector_32_u8();
5313 try expect(v[0] == 69);
5314 try expect(v[1] == 70);
5315 try expect(v[2] == 71);
5316 try expect(v[3] == 72);
5317 try expect(v[4] == 73);
5318 try expect(v[5] == 74);
5319 try expect(v[6] == 75);
5320 try expect(v[7] == 76);
5321 try expect(v[8] == 77);
5322 try expect(v[9] == 78);
5323 try expect(v[10] == 79);
5324 try expect(v[11] == 80);
5325 try expect(v[12] == 81);
5326 try expect(v[13] == 82);
5327 try expect(v[14] == 83);
5328 try expect(v[15] == 84);
5329 try expect(v[16] == 85);
5330 try expect(v[17] == 86);
5331 try expect(v[18] == 87);
5332 try expect(v[19] == 88);
5333 try expect(v[20] == 89);
5334 try expect(v[21] == 90);
5335 try expect(v[22] == 91);
5336 try expect(v[23] == 92);
5337 try expect(v[24] == 93);
5338 try expect(v[25] == 94);
5339 try expect(v[26] == 95);
5340 try expect(v[27] == 96);
5341 try expect(v[28] == 97);
5342 try expect(v[29] == 98);
5343 try expect(v[30] == 99);
5344 try expect(v[31] == 0);
5345 c_vector_32_u8(.{
5346 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
5347 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
5348 }, 32);
5349 c_test_vector_32_u8();
5350}
5351
5352export fn zig_ret_vector_48_u8() @Vector(48, u8) {
5353 return .{
5354 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
5355 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
5356 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
5357 };
5358}
5359export fn zig_vector_48_u8(v: @Vector(48, u8), i: usize) void {
5360 expect(v[0] == 81) catch @panic("test failure");
5361 expect(v[1] == 82) catch @panic("test failure");
5362 expect(v[2] == 83) catch @panic("test failure");
5363 expect(v[3] == 84) catch @panic("test failure");
5364 expect(v[4] == 85) catch @panic("test failure");
5365 expect(v[5] == 86) catch @panic("test failure");
5366 expect(v[6] == 87) catch @panic("test failure");
5367 expect(v[7] == 88) catch @panic("test failure");
5368 expect(v[8] == 89) catch @panic("test failure");
5369 expect(v[9] == 90) catch @panic("test failure");
5370 expect(v[10] == 91) catch @panic("test failure");
5371 expect(v[11] == 92) catch @panic("test failure");
5372 expect(v[12] == 93) catch @panic("test failure");
5373 expect(v[13] == 94) catch @panic("test failure");
5374 expect(v[14] == 95) catch @panic("test failure");
5375 expect(v[15] == 96) catch @panic("test failure");
5376 expect(v[16] == 97) catch @panic("test failure");
5377 expect(v[17] == 98) catch @panic("test failure");
5378 expect(v[18] == 99) catch @panic("test failure");
5379 expect(v[19] == 0) catch @panic("test failure");
5380 expect(v[20] == 1) catch @panic("test failure");
5381 expect(v[21] == 2) catch @panic("test failure");
5382 expect(v[22] == 3) catch @panic("test failure");
5383 expect(v[23] == 4) catch @panic("test failure");
5384 expect(v[24] == 5) catch @panic("test failure");
5385 expect(v[25] == 6) catch @panic("test failure");
5386 expect(v[26] == 7) catch @panic("test failure");
5387 expect(v[27] == 8) catch @panic("test failure");
5388 expect(v[28] == 9) catch @panic("test failure");
5389 expect(v[29] == 10) catch @panic("test failure");
5390 expect(v[30] == 11) catch @panic("test failure");
5391 expect(v[31] == 12) catch @panic("test failure");
5392 expect(v[32] == 13) catch @panic("test failure");
5393 expect(v[33] == 14) catch @panic("test failure");
5394 expect(v[34] == 15) catch @panic("test failure");
5395 expect(v[35] == 16) catch @panic("test failure");
5396 expect(v[36] == 17) catch @panic("test failure");
5397 expect(v[37] == 18) catch @panic("test failure");
5398 expect(v[38] == 19) catch @panic("test failure");
5399 expect(v[39] == 20) catch @panic("test failure");
5400 expect(v[40] == 21) catch @panic("test failure");
5401 expect(v[41] == 22) catch @panic("test failure");
5402 expect(v[42] == 23) catch @panic("test failure");
5403 expect(v[43] == 24) catch @panic("test failure");
5404 expect(v[44] == 25) catch @panic("test failure");
5405 expect(v[45] == 26) catch @panic("test failure");
5406 expect(v[46] == 27) catch @panic("test failure");
5407 expect(v[47] == 28) catch @panic("test failure");
5408 expect(i == 48) catch @panic("test failure");
5409}
5410
5411extern fn c_ret_vector_48_u8() @Vector(48, u8);
5412extern fn c_vector_48_u8(@Vector(48, u8), usize) void;
5413extern fn c_test_vector_48_u8() void;
5414
5415test "@Vector(48, u8)" {
5416 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5417 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5418 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
5419 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5420
5421 const v = c_ret_vector_48_u8();
5422 try expect(v[0] == 29);
5423 try expect(v[1] == 30);
5424 try expect(v[2] == 31);
5425 try expect(v[3] == 32);
5426 try expect(v[4] == 33);
5427 try expect(v[5] == 34);
5428 try expect(v[6] == 35);
5429 try expect(v[7] == 36);
5430 try expect(v[8] == 37);
5431 try expect(v[9] == 38);
5432 try expect(v[10] == 39);
5433 try expect(v[11] == 40);
5434 try expect(v[12] == 41);
5435 try expect(v[13] == 42);
5436 try expect(v[14] == 43);
5437 try expect(v[15] == 44);
5438 try expect(v[16] == 45);
5439 try expect(v[17] == 46);
5440 try expect(v[18] == 47);
5441 try expect(v[19] == 48);
5442 try expect(v[20] == 49);
5443 try expect(v[21] == 50);
5444 try expect(v[22] == 51);
5445 try expect(v[23] == 52);
5446 try expect(v[24] == 53);
5447 try expect(v[25] == 54);
5448 try expect(v[26] == 55);
5449 try expect(v[27] == 56);
5450 try expect(v[28] == 57);
5451 try expect(v[29] == 58);
5452 try expect(v[30] == 59);
5453 try expect(v[31] == 60);
5454 try expect(v[32] == 61);
5455 try expect(v[33] == 62);
5456 try expect(v[34] == 63);
5457 try expect(v[35] == 64);
5458 try expect(v[36] == 65);
5459 try expect(v[37] == 66);
5460 try expect(v[38] == 67);
5461 try expect(v[39] == 68);
5462 try expect(v[40] == 69);
5463 try expect(v[41] == 70);
5464 try expect(v[42] == 71);
5465 try expect(v[43] == 72);
5466 try expect(v[44] == 73);
5467 try expect(v[45] == 74);
5468 try expect(v[46] == 75);
5469 try expect(v[47] == 76);
5470 c_vector_48_u8(.{
5471 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
5472 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8,
5473 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
5474 }, 48);
5475 c_test_vector_48_u8();
5476}
5477
5478export fn zig_ret_vector_64_u8() @Vector(64, u8) {
5479 return .{
5480 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
5481 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
5482 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
5483 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
5484 };
5485}
5486export fn zig_vector_64_u8(v: @Vector(64, u8), i: usize) void {
5487 expect(v[0] == 89) catch @panic("test failure");
5488 expect(v[1] == 90) catch @panic("test failure");
5489 expect(v[2] == 91) catch @panic("test failure");
5490 expect(v[3] == 92) catch @panic("test failure");
5491 expect(v[4] == 93) catch @panic("test failure");
5492 expect(v[5] == 94) catch @panic("test failure");
5493 expect(v[6] == 95) catch @panic("test failure");
5494 expect(v[7] == 96) catch @panic("test failure");
5495 expect(v[8] == 97) catch @panic("test failure");
5496 expect(v[9] == 98) catch @panic("test failure");
5497 expect(v[10] == 99) catch @panic("test failure");
5498 expect(v[11] == 0) catch @panic("test failure");
5499 expect(v[12] == 1) catch @panic("test failure");
5500 expect(v[13] == 2) catch @panic("test failure");
5501 expect(v[14] == 3) catch @panic("test failure");
5502 expect(v[15] == 4) catch @panic("test failure");
5503 expect(v[16] == 5) catch @panic("test failure");
5504 expect(v[17] == 6) catch @panic("test failure");
5505 expect(v[18] == 7) catch @panic("test failure");
5506 expect(v[19] == 8) catch @panic("test failure");
5507 expect(v[20] == 9) catch @panic("test failure");
5508 expect(v[21] == 10) catch @panic("test failure");
5509 expect(v[22] == 11) catch @panic("test failure");
5510 expect(v[23] == 12) catch @panic("test failure");
5511 expect(v[24] == 13) catch @panic("test failure");
5512 expect(v[25] == 14) catch @panic("test failure");
5513 expect(v[26] == 15) catch @panic("test failure");
5514 expect(v[27] == 16) catch @panic("test failure");
5515 expect(v[28] == 17) catch @panic("test failure");
5516 expect(v[29] == 18) catch @panic("test failure");
5517 expect(v[30] == 19) catch @panic("test failure");
5518 expect(v[31] == 20) catch @panic("test failure");
5519 expect(v[32] == 21) catch @panic("test failure");
5520 expect(v[33] == 22) catch @panic("test failure");
5521 expect(v[34] == 23) catch @panic("test failure");
5522 expect(v[35] == 24) catch @panic("test failure");
5523 expect(v[36] == 25) catch @panic("test failure");
5524 expect(v[37] == 26) catch @panic("test failure");
5525 expect(v[38] == 27) catch @panic("test failure");
5526 expect(v[39] == 28) catch @panic("test failure");
5527 expect(v[40] == 29) catch @panic("test failure");
5528 expect(v[41] == 30) catch @panic("test failure");
5529 expect(v[42] == 31) catch @panic("test failure");
5530 expect(v[43] == 32) catch @panic("test failure");
5531 expect(v[44] == 33) catch @panic("test failure");
5532 expect(v[45] == 34) catch @panic("test failure");
5533 expect(v[46] == 35) catch @panic("test failure");
5534 expect(v[47] == 36) catch @panic("test failure");
5535 expect(v[48] == 37) catch @panic("test failure");
5536 expect(v[49] == 38) catch @panic("test failure");
5537 expect(v[50] == 39) catch @panic("test failure");
5538 expect(v[51] == 40) catch @panic("test failure");
5539 expect(v[52] == 41) catch @panic("test failure");
5540 expect(v[53] == 42) catch @panic("test failure");
5541 expect(v[54] == 43) catch @panic("test failure");
5542 expect(v[55] == 44) catch @panic("test failure");
5543 expect(v[56] == 45) catch @panic("test failure");
5544 expect(v[57] == 46) catch @panic("test failure");
5545 expect(v[58] == 47) catch @panic("test failure");
5546 expect(v[59] == 48) catch @panic("test failure");
5547 expect(v[60] == 49) catch @panic("test failure");
5548 expect(v[61] == 50) catch @panic("test failure");
5549 expect(v[62] == 51) catch @panic("test failure");
5550 expect(v[63] == 52) catch @panic("test failure");
5551 expect(i == 64) catch @panic("test failure");
5552}
5553
5554extern fn c_ret_vector_64_u8() @Vector(64, u8);
5555extern fn c_vector_64_u8(@Vector(64, u8), usize) void;
5556extern fn c_test_vector_64_u8() void;
5557
5558test "@Vector(64, u8)" {
5559 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5560 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5561 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5562
5563 const v = c_ret_vector_64_u8();
5564 try expect(v[0] == 53);
5565 try expect(v[1] == 54);
5566 try expect(v[2] == 55);
5567 try expect(v[3] == 56);
5568 try expect(v[4] == 57);
5569 try expect(v[5] == 58);
5570 try expect(v[6] == 59);
5571 try expect(v[7] == 60);
5572 try expect(v[8] == 61);
5573 try expect(v[9] == 62);
5574 try expect(v[10] == 63);
5575 try expect(v[11] == 64);
5576 try expect(v[12] == 65);
5577 try expect(v[13] == 66);
5578 try expect(v[14] == 67);
5579 try expect(v[15] == 68);
5580 try expect(v[16] == 69);
5581 try expect(v[17] == 70);
5582 try expect(v[18] == 71);
5583 try expect(v[19] == 72);
5584 try expect(v[20] == 73);
5585 try expect(v[21] == 74);
5586 try expect(v[22] == 75);
5587 try expect(v[23] == 76);
5588 try expect(v[24] == 77);
5589 try expect(v[25] == 78);
5590 try expect(v[26] == 79);
5591 try expect(v[27] == 80);
5592 try expect(v[28] == 81);
5593 try expect(v[29] == 82);
5594 try expect(v[30] == 83);
5595 try expect(v[31] == 84);
5596 try expect(v[32] == 85);
5597 try expect(v[33] == 86);
5598 try expect(v[34] == 87);
5599 try expect(v[35] == 88);
5600 try expect(v[36] == 89);
5601 try expect(v[37] == 90);
5602 try expect(v[38] == 91);
5603 try expect(v[39] == 92);
5604 try expect(v[40] == 93);
5605 try expect(v[41] == 94);
5606 try expect(v[42] == 95);
5607 try expect(v[43] == 96);
5608 try expect(v[44] == 97);
5609 try expect(v[45] == 98);
5610 try expect(v[46] == 99);
5611 try expect(v[47] == 0);
5612 try expect(v[48] == 1);
5613 try expect(v[49] == 2);
5614 try expect(v[50] == 3);
5615 try expect(v[51] == 4);
5616 try expect(v[52] == 5);
5617 try expect(v[53] == 6);
5618 try expect(v[54] == 7);
5619 try expect(v[55] == 8);
5620 try expect(v[56] == 9);
5621 try expect(v[57] == 10);
5622 try expect(v[58] == 11);
5623 try expect(v[59] == 12);
5624 try expect(v[60] == 13);
5625 try expect(v[61] == 14);
5626 try expect(v[62] == 15);
5627 try expect(v[63] == 16);
5628 c_vector_64_u8(.{
5629 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
5630 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
5631 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
5632 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
5633 }, 64);
5634 c_test_vector_64_u8();
5635}
5636
5637export fn zig_ret_vector_96_u8() @Vector(96, u8) {
5638 return .{
5639 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
5640 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
5641 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
5642 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
5643 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
5644 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
5645 };
5646}
5647export fn zig_vector_96_u8(v: @Vector(96, u8), i: usize) void {
5648 expect(v[0] == 86) catch @panic("test failure");
5649 expect(v[1] == 87) catch @panic("test failure");
5650 expect(v[2] == 88) catch @panic("test failure");
5651 expect(v[3] == 89) catch @panic("test failure");
5652 expect(v[4] == 90) catch @panic("test failure");
5653 expect(v[5] == 91) catch @panic("test failure");
5654 expect(v[6] == 92) catch @panic("test failure");
5655 expect(v[7] == 93) catch @panic("test failure");
5656 expect(v[8] == 94) catch @panic("test failure");
5657 expect(v[9] == 95) catch @panic("test failure");
5658 expect(v[10] == 96) catch @panic("test failure");
5659 expect(v[11] == 97) catch @panic("test failure");
5660 expect(v[12] == 98) catch @panic("test failure");
5661 expect(v[13] == 99) catch @panic("test failure");
5662 expect(v[14] == 0) catch @panic("test failure");
5663 expect(v[15] == 1) catch @panic("test failure");
5664 expect(v[16] == 2) catch @panic("test failure");
5665 expect(v[17] == 3) catch @panic("test failure");
5666 expect(v[18] == 4) catch @panic("test failure");
5667 expect(v[19] == 5) catch @panic("test failure");
5668 expect(v[20] == 6) catch @panic("test failure");
5669 expect(v[21] == 7) catch @panic("test failure");
5670 expect(v[22] == 8) catch @panic("test failure");
5671 expect(v[23] == 9) catch @panic("test failure");
5672 expect(v[24] == 10) catch @panic("test failure");
5673 expect(v[25] == 11) catch @panic("test failure");
5674 expect(v[26] == 12) catch @panic("test failure");
5675 expect(v[27] == 13) catch @panic("test failure");
5676 expect(v[28] == 14) catch @panic("test failure");
5677 expect(v[29] == 15) catch @panic("test failure");
5678 expect(v[30] == 16) catch @panic("test failure");
5679 expect(v[31] == 17) catch @panic("test failure");
5680 expect(v[32] == 18) catch @panic("test failure");
5681 expect(v[33] == 19) catch @panic("test failure");
5682 expect(v[34] == 20) catch @panic("test failure");
5683 expect(v[35] == 21) catch @panic("test failure");
5684 expect(v[36] == 22) catch @panic("test failure");
5685 expect(v[37] == 23) catch @panic("test failure");
5686 expect(v[38] == 24) catch @panic("test failure");
5687 expect(v[39] == 25) catch @panic("test failure");
5688 expect(v[40] == 26) catch @panic("test failure");
5689 expect(v[41] == 27) catch @panic("test failure");
5690 expect(v[42] == 28) catch @panic("test failure");
5691 expect(v[43] == 29) catch @panic("test failure");
5692 expect(v[44] == 30) catch @panic("test failure");
5693 expect(v[45] == 31) catch @panic("test failure");
5694 expect(v[46] == 32) catch @panic("test failure");
5695 expect(v[47] == 33) catch @panic("test failure");
5696 expect(v[48] == 34) catch @panic("test failure");
5697 expect(v[49] == 35) catch @panic("test failure");
5698 expect(v[50] == 36) catch @panic("test failure");
5699 expect(v[51] == 37) catch @panic("test failure");
5700 expect(v[52] == 38) catch @panic("test failure");
5701 expect(v[53] == 39) catch @panic("test failure");
5702 expect(v[54] == 40) catch @panic("test failure");
5703 expect(v[55] == 41) catch @panic("test failure");
5704 expect(v[56] == 42) catch @panic("test failure");
5705 expect(v[57] == 43) catch @panic("test failure");
5706 expect(v[58] == 44) catch @panic("test failure");
5707 expect(v[59] == 45) catch @panic("test failure");
5708 expect(v[60] == 46) catch @panic("test failure");
5709 expect(v[61] == 47) catch @panic("test failure");
5710 expect(v[62] == 48) catch @panic("test failure");
5711 expect(v[63] == 49) catch @panic("test failure");
5712 expect(v[64] == 50) catch @panic("test failure");
5713 expect(v[65] == 51) catch @panic("test failure");
5714 expect(v[66] == 52) catch @panic("test failure");
5715 expect(v[67] == 53) catch @panic("test failure");
5716 expect(v[68] == 54) catch @panic("test failure");
5717 expect(v[69] == 55) catch @panic("test failure");
5718 expect(v[70] == 56) catch @panic("test failure");
5719 expect(v[71] == 57) catch @panic("test failure");
5720 expect(v[72] == 58) catch @panic("test failure");
5721 expect(v[73] == 59) catch @panic("test failure");
5722 expect(v[74] == 60) catch @panic("test failure");
5723 expect(v[75] == 61) catch @panic("test failure");
5724 expect(v[76] == 62) catch @panic("test failure");
5725 expect(v[77] == 63) catch @panic("test failure");
5726 expect(v[78] == 64) catch @panic("test failure");
5727 expect(v[79] == 65) catch @panic("test failure");
5728 expect(v[80] == 66) catch @panic("test failure");
5729 expect(v[81] == 67) catch @panic("test failure");
5730 expect(v[82] == 68) catch @panic("test failure");
5731 expect(v[83] == 69) catch @panic("test failure");
5732 expect(v[84] == 70) catch @panic("test failure");
5733 expect(v[85] == 71) catch @panic("test failure");
5734 expect(v[86] == 72) catch @panic("test failure");
5735 expect(v[87] == 73) catch @panic("test failure");
5736 expect(v[88] == 74) catch @panic("test failure");
5737 expect(v[89] == 75) catch @panic("test failure");
5738 expect(v[90] == 76) catch @panic("test failure");
5739 expect(v[91] == 77) catch @panic("test failure");
5740 expect(v[92] == 78) catch @panic("test failure");
5741 expect(v[93] == 79) catch @panic("test failure");
5742 expect(v[94] == 80) catch @panic("test failure");
5743 expect(v[95] == 81) catch @panic("test failure");
5744 expect(i == 96) catch @panic("test failure");
5745}
5746
5747extern fn c_ret_vector_96_u8() @Vector(96, u8);
5748extern fn c_vector_96_u8(@Vector(96, u8), usize) void;
5749extern fn c_test_vector_96_u8() void;
5750
5751test "@Vector(96, u8)" {
5752 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
5753 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
5754 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
5755 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
5756
5757 const v = c_ret_vector_96_u8();
5758 try expect(v[0] == 82);
5759 try expect(v[1] == 83);
5760 try expect(v[2] == 84);
5761 try expect(v[3] == 85);
5762 try expect(v[4] == 86);
5763 try expect(v[5] == 87);
5764 try expect(v[6] == 88);
5765 try expect(v[7] == 89);
5766 try expect(v[8] == 90);
5767 try expect(v[9] == 91);
5768 try expect(v[10] == 92);
5769 try expect(v[11] == 93);
5770 try expect(v[12] == 94);
5771 try expect(v[13] == 95);
5772 try expect(v[14] == 96);
5773 try expect(v[15] == 97);
5774 try expect(v[16] == 98);
5775 try expect(v[17] == 99);
5776 try expect(v[18] == 0);
5777 try expect(v[19] == 1);
5778 try expect(v[20] == 2);
5779 try expect(v[21] == 3);
5780 try expect(v[22] == 4);
5781 try expect(v[23] == 5);
5782 try expect(v[24] == 6);
5783 try expect(v[25] == 7);
5784 try expect(v[26] == 8);
5785 try expect(v[27] == 9);
5786 try expect(v[28] == 10);
5787 try expect(v[29] == 11);
5788 try expect(v[30] == 12);
5789 try expect(v[31] == 13);
5790 try expect(v[32] == 14);
5791 try expect(v[33] == 15);
5792 try expect(v[34] == 16);
5793 try expect(v[35] == 17);
5794 try expect(v[36] == 18);
5795 try expect(v[37] == 19);
5796 try expect(v[38] == 20);
5797 try expect(v[39] == 21);
5798 try expect(v[40] == 22);
5799 try expect(v[41] == 23);
5800 try expect(v[42] == 24);
5801 try expect(v[43] == 25);
5802 try expect(v[44] == 26);
5803 try expect(v[45] == 27);
5804 try expect(v[46] == 28);
5805 try expect(v[47] == 29);
5806 try expect(v[48] == 30);
5807 try expect(v[49] == 31);
5808 try expect(v[50] == 32);
5809 try expect(v[51] == 33);
5810 try expect(v[52] == 34);
5811 try expect(v[53] == 35);
5812 try expect(v[54] == 36);
5813 try expect(v[55] == 37);
5814 try expect(v[56] == 38);
5815 try expect(v[57] == 39);
5816 try expect(v[58] == 40);
5817 try expect(v[59] == 41);
5818 try expect(v[60] == 42);
5819 try expect(v[61] == 43);
5820 try expect(v[62] == 44);
5821 try expect(v[63] == 45);
5822 try expect(v[64] == 46);
5823 try expect(v[65] == 47);
5824 try expect(v[66] == 48);
5825 try expect(v[67] == 49);
5826 try expect(v[68] == 50);
5827 try expect(v[69] == 51);
5828 try expect(v[70] == 52);
5829 try expect(v[71] == 53);
5830 try expect(v[72] == 54);
5831 try expect(v[73] == 55);
5832 try expect(v[74] == 56);
5833 try expect(v[75] == 57);
5834 try expect(v[76] == 58);
5835 try expect(v[77] == 59);
5836 try expect(v[78] == 60);
5837 try expect(v[79] == 61);
5838 try expect(v[80] == 62);
5839 try expect(v[81] == 63);
5840 try expect(v[82] == 64);
5841 try expect(v[83] == 65);
5842 try expect(v[84] == 66);
5843 try expect(v[85] == 67);
5844 try expect(v[86] == 68);
5845 try expect(v[87] == 69);
5846 try expect(v[88] == 70);
5847 try expect(v[89] == 71);
5848 try expect(v[90] == 72);
5849 try expect(v[91] == 73);
5850 try expect(v[92] == 74);
5851 try expect(v[93] == 75);
5852 try expect(v[94] == 76);
5853 try expect(v[95] == 77);
5854 c_vector_96_u8(.{
5855 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
5856 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
5857 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
5858 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
5859 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
5860 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
5861 }, 96);
5862 c_test_vector_96_u8();
5863}
5864
5865export fn zig_ret_vector_128_u8() @Vector(128, u8) {
5866 return .{
5867 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
5868 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
5869 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
5870 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
5871 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
5872 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
5873 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
5874 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
5875 };
5876}
5877export fn zig_vector_128_u8(v: @Vector(128, u8), i: usize) void {
5878 expect(v[0] == 2) catch @panic("test failure");
5879 expect(v[1] == 3) catch @panic("test failure");
5880 expect(v[2] == 4) catch @panic("test failure");
5881 expect(v[3] == 5) catch @panic("test failure");
5882 expect(v[4] == 6) catch @panic("test failure");
5883 expect(v[5] == 7) catch @panic("test failure");
5884 expect(v[6] == 8) catch @panic("test failure");
5885 expect(v[7] == 9) catch @panic("test failure");
5886 expect(v[8] == 10) catch @panic("test failure");
5887 expect(v[9] == 11) catch @panic("test failure");
5888 expect(v[10] == 12) catch @panic("test failure");
5889 expect(v[11] == 13) catch @panic("test failure");
5890 expect(v[12] == 14) catch @panic("test failure");
5891 expect(v[13] == 15) catch @panic("test failure");
5892 expect(v[14] == 16) catch @panic("test failure");
5893 expect(v[15] == 17) catch @panic("test failure");
5894 expect(v[16] == 18) catch @panic("test failure");
5895 expect(v[17] == 19) catch @panic("test failure");
5896 expect(v[18] == 20) catch @panic("test failure");
5897 expect(v[19] == 21) catch @panic("test failure");
5898 expect(v[20] == 22) catch @panic("test failure");
5899 expect(v[21] == 23) catch @panic("test failure");
5900 expect(v[22] == 24) catch @panic("test failure");
5901 expect(v[23] == 25) catch @panic("test failure");
5902 expect(v[24] == 26) catch @panic("test failure");
5903 expect(v[25] == 27) catch @panic("test failure");
5904 expect(v[26] == 28) catch @panic("test failure");
5905 expect(v[27] == 29) catch @panic("test failure");
5906 expect(v[28] == 30) catch @panic("test failure");
5907 expect(v[29] == 31) catch @panic("test failure");
5908 expect(v[30] == 32) catch @panic("test failure");
5909 expect(v[31] == 33) catch @panic("test failure");
5910 expect(v[32] == 34) catch @panic("test failure");
5911 expect(v[33] == 35) catch @panic("test failure");
5912 expect(v[34] == 36) catch @panic("test failure");
5913 expect(v[35] == 37) catch @panic("test failure");
5914 expect(v[36] == 38) catch @panic("test failure");
5915 expect(v[37] == 39) catch @panic("test failure");
5916 expect(v[38] == 40) catch @panic("test failure");
5917 expect(v[39] == 41) catch @panic("test failure");
5918 expect(v[40] == 42) catch @panic("test failure");
5919 expect(v[41] == 43) catch @panic("test failure");
5920 expect(v[42] == 44) catch @panic("test failure");
5921 expect(v[43] == 45) catch @panic("test failure");
5922 expect(v[44] == 46) catch @panic("test failure");
5923 expect(v[45] == 47) catch @panic("test failure");
5924 expect(v[46] == 48) catch @panic("test failure");
5925 expect(v[47] == 49) catch @panic("test failure");
5926 expect(v[48] == 50) catch @panic("test failure");
5927 expect(v[49] == 51) catch @panic("test failure");
5928 expect(v[50] == 52) catch @panic("test failure");
5929 expect(v[51] == 53) catch @panic("test failure");
5930 expect(v[52] == 54) catch @panic("test failure");
5931 expect(v[53] == 55) catch @panic("test failure");
5932 expect(v[54] == 56) catch @panic("test failure");
5933 expect(v[55] == 57) catch @panic("test failure");
5934 expect(v[56] == 58) catch @panic("test failure");
5935 expect(v[57] == 59) catch @panic("test failure");
5936 expect(v[58] == 60) catch @panic("test failure");
5937 expect(v[59] == 61) catch @panic("test failure");
5938 expect(v[60] == 62) catch @panic("test failure");
5939 expect(v[61] == 63) catch @panic("test failure");
5940 expect(v[62] == 64) catch @panic("test failure");
5941 expect(v[63] == 65) catch @panic("test failure");
5942 expect(v[64] == 66) catch @panic("test failure");
5943 expect(v[65] == 67) catch @panic("test failure");
5944 expect(v[66] == 68) catch @panic("test failure");
5945 expect(v[67] == 69) catch @panic("test failure");
5946 expect(v[68] == 70) catch @panic("test failure");
5947 expect(v[69] == 71) catch @panic("test failure");
5948 expect(v[70] == 72) catch @panic("test failure");
5949 expect(v[71] == 73) catch @panic("test failure");
5950 expect(v[72] == 74) catch @panic("test failure");
5951 expect(v[73] == 75) catch @panic("test failure");
5952 expect(v[74] == 76) catch @panic("test failure");
5953 expect(v[75] == 77) catch @panic("test failure");
5954 expect(v[76] == 78) catch @panic("test failure");
5955 expect(v[77] == 79) catch @panic("test failure");
5956 expect(v[78] == 80) catch @panic("test failure");
5957 expect(v[79] == 81) catch @panic("test failure");
5958 expect(v[80] == 82) catch @panic("test failure");
5959 expect(v[81] == 83) catch @panic("test failure");
5960 expect(v[82] == 84) catch @panic("test failure");
5961 expect(v[83] == 85) catch @panic("test failure");
5962 expect(v[84] == 86) catch @panic("test failure");
5963 expect(v[85] == 87) catch @panic("test failure");
5964 expect(v[86] == 88) catch @panic("test failure");
5965 expect(v[87] == 89) catch @panic("test failure");
5966 expect(v[88] == 90) catch @panic("test failure");
5967 expect(v[89] == 91) catch @panic("test failure");
5968 expect(v[90] == 92) catch @panic("test failure");
5969 expect(v[91] == 93) catch @panic("test failure");
5970 expect(v[92] == 94) catch @panic("test failure");
5971 expect(v[93] == 95) catch @panic("test failure");
5972 expect(v[94] == 96) catch @panic("test failure");
5973 expect(v[95] == 97) catch @panic("test failure");
5974 expect(v[96] == 98) catch @panic("test failure");
5975 expect(v[97] == 99) catch @panic("test failure");
5976 expect(v[98] == 0) catch @panic("test failure");
5977 expect(v[99] == 1) catch @panic("test failure");
5978 expect(v[100] == 2) catch @panic("test failure");
5979 expect(v[101] == 3) catch @panic("test failure");
5980 expect(v[102] == 4) catch @panic("test failure");
5981 expect(v[103] == 5) catch @panic("test failure");
5982 expect(v[104] == 6) catch @panic("test failure");
5983 expect(v[105] == 7) catch @panic("test failure");
5984 expect(v[106] == 8) catch @panic("test failure");
5985 expect(v[107] == 9) catch @panic("test failure");
5986 expect(v[108] == 10) catch @panic("test failure");
5987 expect(v[109] == 11) catch @panic("test failure");
5988 expect(v[110] == 12) catch @panic("test failure");
5989 expect(v[111] == 13) catch @panic("test failure");
5990 expect(v[112] == 14) catch @panic("test failure");
5991 expect(v[113] == 15) catch @panic("test failure");
5992 expect(v[114] == 16) catch @panic("test failure");
5993 expect(v[115] == 17) catch @panic("test failure");
5994 expect(v[116] == 18) catch @panic("test failure");
5995 expect(v[117] == 19) catch @panic("test failure");
5996 expect(v[118] == 20) catch @panic("test failure");
5997 expect(v[119] == 21) catch @panic("test failure");
5998 expect(v[120] == 22) catch @panic("test failure");
5999 expect(v[121] == 23) catch @panic("test failure");
6000 expect(v[122] == 24) catch @panic("test failure");
6001 expect(v[123] == 25) catch @panic("test failure");
6002 expect(v[124] == 26) catch @panic("test failure");
6003 expect(v[125] == 27) catch @panic("test failure");
6004 expect(v[126] == 28) catch @panic("test failure");
6005 expect(v[127] == 29) catch @panic("test failure");
6006 expect(i == 128) catch @panic("test failure");
6007}
6008
6009extern fn c_ret_vector_128_u8() @Vector(128, u8);
6010extern fn c_vector_128_u8(@Vector(128, u8), usize) void;
6011extern fn c_test_vector_128_u8() void;
6012
6013test "@Vector(128, u8)" {
6014 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
6015 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
6016 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
6017 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
6018
6019 const v = c_ret_vector_128_u8();
6020 try expect(v[0] == 30);
6021 try expect(v[1] == 31);
6022 try expect(v[2] == 32);
6023 try expect(v[3] == 33);
6024 try expect(v[4] == 34);
6025 try expect(v[5] == 35);
6026 try expect(v[6] == 36);
6027 try expect(v[7] == 37);
6028 try expect(v[8] == 38);
6029 try expect(v[9] == 39);
6030 try expect(v[10] == 40);
6031 try expect(v[11] == 41);
6032 try expect(v[12] == 42);
6033 try expect(v[13] == 43);
6034 try expect(v[14] == 44);
6035 try expect(v[15] == 45);
6036 try expect(v[16] == 46);
6037 try expect(v[17] == 47);
6038 try expect(v[18] == 48);
6039 try expect(v[19] == 49);
6040 try expect(v[20] == 50);
6041 try expect(v[21] == 51);
6042 try expect(v[22] == 52);
6043 try expect(v[23] == 53);
6044 try expect(v[24] == 54);
6045 try expect(v[25] == 55);
6046 try expect(v[26] == 56);
6047 try expect(v[27] == 57);
6048 try expect(v[28] == 58);
6049 try expect(v[29] == 59);
6050 try expect(v[30] == 60);
6051 try expect(v[31] == 61);
6052 try expect(v[32] == 62);
6053 try expect(v[33] == 63);
6054 try expect(v[34] == 64);
6055 try expect(v[35] == 65);
6056 try expect(v[36] == 66);
6057 try expect(v[37] == 67);
6058 try expect(v[38] == 68);
6059 try expect(v[39] == 69);
6060 try expect(v[40] == 70);
6061 try expect(v[41] == 71);
6062 try expect(v[42] == 72);
6063 try expect(v[43] == 73);
6064 try expect(v[44] == 74);
6065 try expect(v[45] == 75);
6066 try expect(v[46] == 76);
6067 try expect(v[47] == 77);
6068 try expect(v[48] == 78);
6069 try expect(v[49] == 79);
6070 try expect(v[50] == 80);
6071 try expect(v[51] == 81);
6072 try expect(v[52] == 82);
6073 try expect(v[53] == 83);
6074 try expect(v[54] == 84);
6075 try expect(v[55] == 85);
6076 try expect(v[56] == 86);
6077 try expect(v[57] == 87);
6078 try expect(v[58] == 88);
6079 try expect(v[59] == 89);
6080 try expect(v[60] == 90);
6081 try expect(v[61] == 91);
6082 try expect(v[62] == 92);
6083 try expect(v[63] == 93);
6084 try expect(v[64] == 94);
6085 try expect(v[65] == 95);
6086 try expect(v[66] == 96);
6087 try expect(v[67] == 97);
6088 try expect(v[68] == 98);
6089 try expect(v[69] == 99);
6090 try expect(v[70] == 0);
6091 try expect(v[71] == 1);
6092 try expect(v[72] == 2);
6093 try expect(v[73] == 3);
6094 try expect(v[74] == 4);
6095 try expect(v[75] == 5);
6096 try expect(v[76] == 6);
6097 try expect(v[77] == 7);
6098 try expect(v[78] == 8);
6099 try expect(v[79] == 9);
6100 try expect(v[80] == 10);
6101 try expect(v[81] == 11);
6102 try expect(v[82] == 12);
6103 try expect(v[83] == 13);
6104 try expect(v[84] == 14);
6105 try expect(v[85] == 15);
6106 try expect(v[86] == 16);
6107 try expect(v[87] == 17);
6108 try expect(v[88] == 18);
6109 try expect(v[89] == 19);
6110 try expect(v[90] == 20);
6111 try expect(v[91] == 21);
6112 try expect(v[92] == 22);
6113 try expect(v[93] == 23);
6114 try expect(v[94] == 24);
6115 try expect(v[95] == 25);
6116 try expect(v[96] == 26);
6117 try expect(v[97] == 27);
6118 try expect(v[98] == 28);
6119 try expect(v[99] == 29);
6120 try expect(v[100] == 30);
6121 try expect(v[101] == 31);
6122 try expect(v[102] == 32);
6123 try expect(v[103] == 33);
6124 try expect(v[104] == 34);
6125 try expect(v[105] == 35);
6126 try expect(v[106] == 36);
6127 try expect(v[107] == 37);
6128 try expect(v[108] == 38);
6129 try expect(v[109] == 39);
6130 try expect(v[110] == 40);
6131 try expect(v[111] == 41);
6132 try expect(v[112] == 42);
6133 try expect(v[113] == 43);
6134 try expect(v[114] == 44);
6135 try expect(v[115] == 45);
6136 try expect(v[116] == 46);
6137 try expect(v[117] == 47);
6138 try expect(v[118] == 48);
6139 try expect(v[119] == 49);
6140 try expect(v[120] == 50);
6141 try expect(v[121] == 51);
6142 try expect(v[122] == 52);
6143 try expect(v[123] == 53);
6144 try expect(v[124] == 54);
6145 try expect(v[125] == 55);
6146 try expect(v[126] == 56);
6147 try expect(v[127] == 57);
6148 c_vector_128_u8(.{
6149 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6150 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6151 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6152 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6153 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
6154 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6155 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
6156 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
6157 }, 128);
6158 c_test_vector_128_u8();
6159}
6160
6161export fn zig_ret_vector_192_u8() @Vector(192, u8) {
6162 return .{
6163 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
6164 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6165 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
6166 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
6167 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6168 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
6169 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
6170 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6171 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
6172 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
6173 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
6174 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
6175 };
6176}
6177export fn zig_vector_192_u8(v: @Vector(192, u8), i: usize) void {
6178 expect(v[0] == 78) catch @panic("test failure");
6179 expect(v[1] == 79) catch @panic("test failure");
6180 expect(v[2] == 80) catch @panic("test failure");
6181 expect(v[3] == 81) catch @panic("test failure");
6182 expect(v[4] == 82) catch @panic("test failure");
6183 expect(v[5] == 83) catch @panic("test failure");
6184 expect(v[6] == 84) catch @panic("test failure");
6185 expect(v[7] == 85) catch @panic("test failure");
6186 expect(v[8] == 86) catch @panic("test failure");
6187 expect(v[9] == 87) catch @panic("test failure");
6188 expect(v[10] == 88) catch @panic("test failure");
6189 expect(v[11] == 89) catch @panic("test failure");
6190 expect(v[12] == 90) catch @panic("test failure");
6191 expect(v[13] == 91) catch @panic("test failure");
6192 expect(v[14] == 92) catch @panic("test failure");
6193 expect(v[15] == 93) catch @panic("test failure");
6194 expect(v[16] == 94) catch @panic("test failure");
6195 expect(v[17] == 95) catch @panic("test failure");
6196 expect(v[18] == 96) catch @panic("test failure");
6197 expect(v[19] == 97) catch @panic("test failure");
6198 expect(v[20] == 98) catch @panic("test failure");
6199 expect(v[21] == 99) catch @panic("test failure");
6200 expect(v[22] == 0) catch @panic("test failure");
6201 expect(v[23] == 1) catch @panic("test failure");
6202 expect(v[24] == 2) catch @panic("test failure");
6203 expect(v[25] == 3) catch @panic("test failure");
6204 expect(v[26] == 4) catch @panic("test failure");
6205 expect(v[27] == 5) catch @panic("test failure");
6206 expect(v[28] == 6) catch @panic("test failure");
6207 expect(v[29] == 7) catch @panic("test failure");
6208 expect(v[30] == 8) catch @panic("test failure");
6209 expect(v[31] == 9) catch @panic("test failure");
6210 expect(v[32] == 10) catch @panic("test failure");
6211 expect(v[33] == 11) catch @panic("test failure");
6212 expect(v[34] == 12) catch @panic("test failure");
6213 expect(v[35] == 13) catch @panic("test failure");
6214 expect(v[36] == 14) catch @panic("test failure");
6215 expect(v[37] == 15) catch @panic("test failure");
6216 expect(v[38] == 16) catch @panic("test failure");
6217 expect(v[39] == 17) catch @panic("test failure");
6218 expect(v[40] == 18) catch @panic("test failure");
6219 expect(v[41] == 19) catch @panic("test failure");
6220 expect(v[42] == 20) catch @panic("test failure");
6221 expect(v[43] == 21) catch @panic("test failure");
6222 expect(v[44] == 22) catch @panic("test failure");
6223 expect(v[45] == 23) catch @panic("test failure");
6224 expect(v[46] == 24) catch @panic("test failure");
6225 expect(v[47] == 25) catch @panic("test failure");
6226 expect(v[48] == 26) catch @panic("test failure");
6227 expect(v[49] == 27) catch @panic("test failure");
6228 expect(v[50] == 28) catch @panic("test failure");
6229 expect(v[51] == 29) catch @panic("test failure");
6230 expect(v[52] == 30) catch @panic("test failure");
6231 expect(v[53] == 31) catch @panic("test failure");
6232 expect(v[54] == 32) catch @panic("test failure");
6233 expect(v[55] == 33) catch @panic("test failure");
6234 expect(v[56] == 34) catch @panic("test failure");
6235 expect(v[57] == 35) catch @panic("test failure");
6236 expect(v[58] == 36) catch @panic("test failure");
6237 expect(v[59] == 37) catch @panic("test failure");
6238 expect(v[60] == 38) catch @panic("test failure");
6239 expect(v[61] == 39) catch @panic("test failure");
6240 expect(v[62] == 40) catch @panic("test failure");
6241 expect(v[63] == 41) catch @panic("test failure");
6242 expect(v[64] == 42) catch @panic("test failure");
6243 expect(v[65] == 43) catch @panic("test failure");
6244 expect(v[66] == 44) catch @panic("test failure");
6245 expect(v[67] == 45) catch @panic("test failure");
6246 expect(v[68] == 46) catch @panic("test failure");
6247 expect(v[69] == 47) catch @panic("test failure");
6248 expect(v[70] == 48) catch @panic("test failure");
6249 expect(v[71] == 49) catch @panic("test failure");
6250 expect(v[72] == 50) catch @panic("test failure");
6251 expect(v[73] == 51) catch @panic("test failure");
6252 expect(v[74] == 52) catch @panic("test failure");
6253 expect(v[75] == 53) catch @panic("test failure");
6254 expect(v[76] == 54) catch @panic("test failure");
6255 expect(v[77] == 55) catch @panic("test failure");
6256 expect(v[78] == 56) catch @panic("test failure");
6257 expect(v[79] == 57) catch @panic("test failure");
6258 expect(v[80] == 58) catch @panic("test failure");
6259 expect(v[81] == 59) catch @panic("test failure");
6260 expect(v[82] == 60) catch @panic("test failure");
6261 expect(v[83] == 61) catch @panic("test failure");
6262 expect(v[84] == 62) catch @panic("test failure");
6263 expect(v[85] == 63) catch @panic("test failure");
6264 expect(v[86] == 64) catch @panic("test failure");
6265 expect(v[87] == 65) catch @panic("test failure");
6266 expect(v[88] == 66) catch @panic("test failure");
6267 expect(v[89] == 67) catch @panic("test failure");
6268 expect(v[90] == 68) catch @panic("test failure");
6269 expect(v[91] == 69) catch @panic("test failure");
6270 expect(v[92] == 70) catch @panic("test failure");
6271 expect(v[93] == 71) catch @panic("test failure");
6272 expect(v[94] == 72) catch @panic("test failure");
6273 expect(v[95] == 73) catch @panic("test failure");
6274 expect(v[96] == 74) catch @panic("test failure");
6275 expect(v[97] == 75) catch @panic("test failure");
6276 expect(v[98] == 76) catch @panic("test failure");
6277 expect(v[99] == 77) catch @panic("test failure");
6278 expect(v[100] == 78) catch @panic("test failure");
6279 expect(v[101] == 79) catch @panic("test failure");
6280 expect(v[102] == 80) catch @panic("test failure");
6281 expect(v[103] == 81) catch @panic("test failure");
6282 expect(v[104] == 82) catch @panic("test failure");
6283 expect(v[105] == 83) catch @panic("test failure");
6284 expect(v[106] == 84) catch @panic("test failure");
6285 expect(v[107] == 85) catch @panic("test failure");
6286 expect(v[108] == 86) catch @panic("test failure");
6287 expect(v[109] == 87) catch @panic("test failure");
6288 expect(v[110] == 88) catch @panic("test failure");
6289 expect(v[111] == 89) catch @panic("test failure");
6290 expect(v[112] == 90) catch @panic("test failure");
6291 expect(v[113] == 91) catch @panic("test failure");
6292 expect(v[114] == 92) catch @panic("test failure");
6293 expect(v[115] == 93) catch @panic("test failure");
6294 expect(v[116] == 94) catch @panic("test failure");
6295 expect(v[117] == 95) catch @panic("test failure");
6296 expect(v[118] == 96) catch @panic("test failure");
6297 expect(v[119] == 97) catch @panic("test failure");
6298 expect(v[120] == 98) catch @panic("test failure");
6299 expect(v[121] == 99) catch @panic("test failure");
6300 expect(v[122] == 0) catch @panic("test failure");
6301 expect(v[123] == 1) catch @panic("test failure");
6302 expect(v[124] == 2) catch @panic("test failure");
6303 expect(v[125] == 3) catch @panic("test failure");
6304 expect(v[126] == 4) catch @panic("test failure");
6305 expect(v[127] == 5) catch @panic("test failure");
6306 expect(v[128] == 6) catch @panic("test failure");
6307 expect(v[129] == 7) catch @panic("test failure");
6308 expect(v[130] == 8) catch @panic("test failure");
6309 expect(v[131] == 9) catch @panic("test failure");
6310 expect(v[132] == 10) catch @panic("test failure");
6311 expect(v[133] == 11) catch @panic("test failure");
6312 expect(v[134] == 12) catch @panic("test failure");
6313 expect(v[135] == 13) catch @panic("test failure");
6314 expect(v[136] == 14) catch @panic("test failure");
6315 expect(v[137] == 15) catch @panic("test failure");
6316 expect(v[138] == 16) catch @panic("test failure");
6317 expect(v[139] == 17) catch @panic("test failure");
6318 expect(v[140] == 18) catch @panic("test failure");
6319 expect(v[141] == 19) catch @panic("test failure");
6320 expect(v[142] == 20) catch @panic("test failure");
6321 expect(v[143] == 21) catch @panic("test failure");
6322 expect(v[144] == 22) catch @panic("test failure");
6323 expect(v[145] == 23) catch @panic("test failure");
6324 expect(v[146] == 24) catch @panic("test failure");
6325 expect(v[147] == 25) catch @panic("test failure");
6326 expect(v[148] == 26) catch @panic("test failure");
6327 expect(v[149] == 27) catch @panic("test failure");
6328 expect(v[150] == 28) catch @panic("test failure");
6329 expect(v[151] == 29) catch @panic("test failure");
6330 expect(v[152] == 30) catch @panic("test failure");
6331 expect(v[153] == 31) catch @panic("test failure");
6332 expect(v[154] == 32) catch @panic("test failure");
6333 expect(v[155] == 33) catch @panic("test failure");
6334 expect(v[156] == 34) catch @panic("test failure");
6335 expect(v[157] == 35) catch @panic("test failure");
6336 expect(v[158] == 36) catch @panic("test failure");
6337 expect(v[159] == 37) catch @panic("test failure");
6338 expect(v[160] == 38) catch @panic("test failure");
6339 expect(v[161] == 39) catch @panic("test failure");
6340 expect(v[162] == 40) catch @panic("test failure");
6341 expect(v[163] == 41) catch @panic("test failure");
6342 expect(v[164] == 42) catch @panic("test failure");
6343 expect(v[165] == 43) catch @panic("test failure");
6344 expect(v[166] == 44) catch @panic("test failure");
6345 expect(v[167] == 45) catch @panic("test failure");
6346 expect(v[168] == 46) catch @panic("test failure");
6347 expect(v[169] == 47) catch @panic("test failure");
6348 expect(v[170] == 48) catch @panic("test failure");
6349 expect(v[171] == 49) catch @panic("test failure");
6350 expect(v[172] == 50) catch @panic("test failure");
6351 expect(v[173] == 51) catch @panic("test failure");
6352 expect(v[174] == 52) catch @panic("test failure");
6353 expect(v[175] == 53) catch @panic("test failure");
6354 expect(v[176] == 54) catch @panic("test failure");
6355 expect(v[177] == 55) catch @panic("test failure");
6356 expect(v[178] == 56) catch @panic("test failure");
6357 expect(v[179] == 57) catch @panic("test failure");
6358 expect(v[180] == 58) catch @panic("test failure");
6359 expect(v[181] == 59) catch @panic("test failure");
6360 expect(v[182] == 60) catch @panic("test failure");
6361 expect(v[183] == 61) catch @panic("test failure");
6362 expect(v[184] == 62) catch @panic("test failure");
6363 expect(v[185] == 63) catch @panic("test failure");
6364 expect(v[186] == 64) catch @panic("test failure");
6365 expect(v[187] == 65) catch @panic("test failure");
6366 expect(v[188] == 66) catch @panic("test failure");
6367 expect(v[189] == 67) catch @panic("test failure");
6368 expect(v[190] == 68) catch @panic("test failure");
6369 expect(v[191] == 69) catch @panic("test failure");
6370 expect(i == 192) catch @panic("test failure");
6371}
6372
6373extern fn c_ret_vector_192_u8() @Vector(192, u8);
6374extern fn c_vector_192_u8(@Vector(192, u8), usize) void;
6375extern fn c_test_vector_192_u8() void;
6376
6377test "@Vector(192, u8)" {
6378 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
6379 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
6380 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
6381 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
6382
6383 const v = c_ret_vector_192_u8();
6384 try expect(v[0] == 70);
6385 try expect(v[1] == 71);
6386 try expect(v[2] == 72);
6387 try expect(v[3] == 73);
6388 try expect(v[4] == 74);
6389 try expect(v[5] == 75);
6390 try expect(v[6] == 76);
6391 try expect(v[7] == 77);
6392 try expect(v[8] == 78);
6393 try expect(v[9] == 79);
6394 try expect(v[10] == 80);
6395 try expect(v[11] == 81);
6396 try expect(v[12] == 82);
6397 try expect(v[13] == 83);
6398 try expect(v[14] == 84);
6399 try expect(v[15] == 85);
6400 try expect(v[16] == 86);
6401 try expect(v[17] == 87);
6402 try expect(v[18] == 88);
6403 try expect(v[19] == 89);
6404 try expect(v[20] == 90);
6405 try expect(v[21] == 91);
6406 try expect(v[22] == 92);
6407 try expect(v[23] == 93);
6408 try expect(v[24] == 94);
6409 try expect(v[25] == 95);
6410 try expect(v[26] == 96);
6411 try expect(v[27] == 97);
6412 try expect(v[28] == 98);
6413 try expect(v[29] == 99);
6414 try expect(v[30] == 0);
6415 try expect(v[31] == 1);
6416 try expect(v[32] == 2);
6417 try expect(v[33] == 3);
6418 try expect(v[34] == 4);
6419 try expect(v[35] == 5);
6420 try expect(v[36] == 6);
6421 try expect(v[37] == 7);
6422 try expect(v[38] == 8);
6423 try expect(v[39] == 9);
6424 try expect(v[40] == 10);
6425 try expect(v[41] == 11);
6426 try expect(v[42] == 12);
6427 try expect(v[43] == 13);
6428 try expect(v[44] == 14);
6429 try expect(v[45] == 15);
6430 try expect(v[46] == 16);
6431 try expect(v[47] == 17);
6432 try expect(v[48] == 18);
6433 try expect(v[49] == 19);
6434 try expect(v[50] == 20);
6435 try expect(v[51] == 21);
6436 try expect(v[52] == 22);
6437 try expect(v[53] == 23);
6438 try expect(v[54] == 24);
6439 try expect(v[55] == 25);
6440 try expect(v[56] == 26);
6441 try expect(v[57] == 27);
6442 try expect(v[58] == 28);
6443 try expect(v[59] == 29);
6444 try expect(v[60] == 30);
6445 try expect(v[61] == 31);
6446 try expect(v[62] == 32);
6447 try expect(v[63] == 33);
6448 try expect(v[64] == 34);
6449 try expect(v[65] == 35);
6450 try expect(v[66] == 36);
6451 try expect(v[67] == 37);
6452 try expect(v[68] == 38);
6453 try expect(v[69] == 39);
6454 try expect(v[70] == 40);
6455 try expect(v[71] == 41);
6456 try expect(v[72] == 42);
6457 try expect(v[73] == 43);
6458 try expect(v[74] == 44);
6459 try expect(v[75] == 45);
6460 try expect(v[76] == 46);
6461 try expect(v[77] == 47);
6462 try expect(v[78] == 48);
6463 try expect(v[79] == 49);
6464 try expect(v[80] == 50);
6465 try expect(v[81] == 51);
6466 try expect(v[82] == 52);
6467 try expect(v[83] == 53);
6468 try expect(v[84] == 54);
6469 try expect(v[85] == 55);
6470 try expect(v[86] == 56);
6471 try expect(v[87] == 57);
6472 try expect(v[88] == 58);
6473 try expect(v[89] == 59);
6474 try expect(v[90] == 60);
6475 try expect(v[91] == 61);
6476 try expect(v[92] == 62);
6477 try expect(v[93] == 63);
6478 try expect(v[94] == 64);
6479 try expect(v[95] == 65);
6480 try expect(v[96] == 66);
6481 try expect(v[97] == 67);
6482 try expect(v[98] == 68);
6483 try expect(v[99] == 69);
6484 try expect(v[100] == 70);
6485 try expect(v[101] == 71);
6486 try expect(v[102] == 72);
6487 try expect(v[103] == 73);
6488 try expect(v[104] == 74);
6489 try expect(v[105] == 75);
6490 try expect(v[106] == 76);
6491 try expect(v[107] == 77);
6492 try expect(v[108] == 78);
6493 try expect(v[109] == 79);
6494 try expect(v[110] == 80);
6495 try expect(v[111] == 81);
6496 try expect(v[112] == 82);
6497 try expect(v[113] == 83);
6498 try expect(v[114] == 84);
6499 try expect(v[115] == 85);
6500 try expect(v[116] == 86);
6501 try expect(v[117] == 87);
6502 try expect(v[118] == 88);
6503 try expect(v[119] == 89);
6504 try expect(v[120] == 90);
6505 try expect(v[121] == 91);
6506 try expect(v[122] == 92);
6507 try expect(v[123] == 93);
6508 try expect(v[124] == 94);
6509 try expect(v[125] == 95);
6510 try expect(v[126] == 96);
6511 try expect(v[127] == 97);
6512 try expect(v[128] == 98);
6513 try expect(v[129] == 99);
6514 try expect(v[130] == 0);
6515 try expect(v[131] == 1);
6516 try expect(v[132] == 2);
6517 try expect(v[133] == 3);
6518 try expect(v[134] == 4);
6519 try expect(v[135] == 5);
6520 try expect(v[136] == 6);
6521 try expect(v[137] == 7);
6522 try expect(v[138] == 8);
6523 try expect(v[139] == 9);
6524 try expect(v[140] == 10);
6525 try expect(v[141] == 11);
6526 try expect(v[142] == 12);
6527 try expect(v[143] == 13);
6528 try expect(v[144] == 14);
6529 try expect(v[145] == 15);
6530 try expect(v[146] == 16);
6531 try expect(v[147] == 17);
6532 try expect(v[148] == 18);
6533 try expect(v[149] == 19);
6534 try expect(v[150] == 20);
6535 try expect(v[151] == 21);
6536 try expect(v[152] == 22);
6537 try expect(v[153] == 23);
6538 try expect(v[154] == 24);
6539 try expect(v[155] == 25);
6540 try expect(v[156] == 26);
6541 try expect(v[157] == 27);
6542 try expect(v[158] == 28);
6543 try expect(v[159] == 29);
6544 try expect(v[160] == 30);
6545 try expect(v[161] == 31);
6546 try expect(v[162] == 32);
6547 try expect(v[163] == 33);
6548 try expect(v[164] == 34);
6549 try expect(v[165] == 35);
6550 try expect(v[166] == 36);
6551 try expect(v[167] == 37);
6552 try expect(v[168] == 38);
6553 try expect(v[169] == 39);
6554 try expect(v[170] == 40);
6555 try expect(v[171] == 41);
6556 try expect(v[172] == 42);
6557 try expect(v[173] == 43);
6558 try expect(v[174] == 44);
6559 try expect(v[175] == 45);
6560 try expect(v[176] == 46);
6561 try expect(v[177] == 47);
6562 try expect(v[178] == 48);
6563 try expect(v[179] == 49);
6564 try expect(v[180] == 50);
6565 try expect(v[181] == 51);
6566 try expect(v[182] == 52);
6567 try expect(v[183] == 53);
6568 try expect(v[184] == 54);
6569 try expect(v[185] == 55);
6570 try expect(v[186] == 56);
6571 try expect(v[187] == 57);
6572 try expect(v[188] == 58);
6573 try expect(v[189] == 59);
6574 try expect(v[190] == 60);
6575 try expect(v[191] == 61);
6576 c_vector_192_u8(.{
6577 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
6578 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
6579 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
6580 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6581 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
6582 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6583 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6584 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6585 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6586 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6587 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
6588 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6589 }, 192);
6590 c_test_vector_192_u8();
6591}
6592
6593export fn zig_ret_vector_256_u8() @Vector(256, u8) {
6594 return .{
6595 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
6596 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
6597 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
6598 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6599 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
6600 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
6601 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6602 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
6603 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
6604 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6605 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
6606 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
6607 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
6608 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
6609 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
6610 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
6611 };
6612}
6613export fn zig_vector_256_u8(v: @Vector(256, u8), i: usize) void {
6614 expect(v[0] == 10) catch @panic("test failure");
6615 expect(v[1] == 11) catch @panic("test failure");
6616 expect(v[2] == 12) catch @panic("test failure");
6617 expect(v[3] == 13) catch @panic("test failure");
6618 expect(v[4] == 14) catch @panic("test failure");
6619 expect(v[5] == 15) catch @panic("test failure");
6620 expect(v[6] == 16) catch @panic("test failure");
6621 expect(v[7] == 17) catch @panic("test failure");
6622 expect(v[8] == 18) catch @panic("test failure");
6623 expect(v[9] == 19) catch @panic("test failure");
6624 expect(v[10] == 20) catch @panic("test failure");
6625 expect(v[11] == 21) catch @panic("test failure");
6626 expect(v[12] == 22) catch @panic("test failure");
6627 expect(v[13] == 23) catch @panic("test failure");
6628 expect(v[14] == 24) catch @panic("test failure");
6629 expect(v[15] == 25) catch @panic("test failure");
6630 expect(v[16] == 26) catch @panic("test failure");
6631 expect(v[17] == 27) catch @panic("test failure");
6632 expect(v[18] == 28) catch @panic("test failure");
6633 expect(v[19] == 29) catch @panic("test failure");
6634 expect(v[20] == 30) catch @panic("test failure");
6635 expect(v[21] == 31) catch @panic("test failure");
6636 expect(v[22] == 32) catch @panic("test failure");
6637 expect(v[23] == 33) catch @panic("test failure");
6638 expect(v[24] == 34) catch @panic("test failure");
6639 expect(v[25] == 35) catch @panic("test failure");
6640 expect(v[26] == 36) catch @panic("test failure");
6641 expect(v[27] == 37) catch @panic("test failure");
6642 expect(v[28] == 38) catch @panic("test failure");
6643 expect(v[29] == 39) catch @panic("test failure");
6644 expect(v[30] == 40) catch @panic("test failure");
6645 expect(v[31] == 41) catch @panic("test failure");
6646 expect(v[32] == 42) catch @panic("test failure");
6647 expect(v[33] == 43) catch @panic("test failure");
6648 expect(v[34] == 44) catch @panic("test failure");
6649 expect(v[35] == 45) catch @panic("test failure");
6650 expect(v[36] == 46) catch @panic("test failure");
6651 expect(v[37] == 47) catch @panic("test failure");
6652 expect(v[38] == 48) catch @panic("test failure");
6653 expect(v[39] == 49) catch @panic("test failure");
6654 expect(v[40] == 50) catch @panic("test failure");
6655 expect(v[41] == 51) catch @panic("test failure");
6656 expect(v[42] == 52) catch @panic("test failure");
6657 expect(v[43] == 53) catch @panic("test failure");
6658 expect(v[44] == 54) catch @panic("test failure");
6659 expect(v[45] == 55) catch @panic("test failure");
6660 expect(v[46] == 56) catch @panic("test failure");
6661 expect(v[47] == 57) catch @panic("test failure");
6662 expect(v[48] == 58) catch @panic("test failure");
6663 expect(v[49] == 59) catch @panic("test failure");
6664 expect(v[50] == 60) catch @panic("test failure");
6665 expect(v[51] == 61) catch @panic("test failure");
6666 expect(v[52] == 62) catch @panic("test failure");
6667 expect(v[53] == 63) catch @panic("test failure");
6668 expect(v[54] == 64) catch @panic("test failure");
6669 expect(v[55] == 65) catch @panic("test failure");
6670 expect(v[56] == 66) catch @panic("test failure");
6671 expect(v[57] == 67) catch @panic("test failure");
6672 expect(v[58] == 68) catch @panic("test failure");
6673 expect(v[59] == 69) catch @panic("test failure");
6674 expect(v[60] == 70) catch @panic("test failure");
6675 expect(v[61] == 71) catch @panic("test failure");
6676 expect(v[62] == 72) catch @panic("test failure");
6677 expect(v[63] == 73) catch @panic("test failure");
6678 expect(v[64] == 74) catch @panic("test failure");
6679 expect(v[65] == 75) catch @panic("test failure");
6680 expect(v[66] == 76) catch @panic("test failure");
6681 expect(v[67] == 77) catch @panic("test failure");
6682 expect(v[68] == 78) catch @panic("test failure");
6683 expect(v[69] == 79) catch @panic("test failure");
6684 expect(v[70] == 80) catch @panic("test failure");
6685 expect(v[71] == 81) catch @panic("test failure");
6686 expect(v[72] == 82) catch @panic("test failure");
6687 expect(v[73] == 83) catch @panic("test failure");
6688 expect(v[74] == 84) catch @panic("test failure");
6689 expect(v[75] == 85) catch @panic("test failure");
6690 expect(v[76] == 86) catch @panic("test failure");
6691 expect(v[77] == 87) catch @panic("test failure");
6692 expect(v[78] == 88) catch @panic("test failure");
6693 expect(v[79] == 89) catch @panic("test failure");
6694 expect(v[80] == 90) catch @panic("test failure");
6695 expect(v[81] == 91) catch @panic("test failure");
6696 expect(v[82] == 92) catch @panic("test failure");
6697 expect(v[83] == 93) catch @panic("test failure");
6698 expect(v[84] == 94) catch @panic("test failure");
6699 expect(v[85] == 95) catch @panic("test failure");
6700 expect(v[86] == 96) catch @panic("test failure");
6701 expect(v[87] == 97) catch @panic("test failure");
6702 expect(v[88] == 98) catch @panic("test failure");
6703 expect(v[89] == 99) catch @panic("test failure");
6704 expect(v[90] == 0) catch @panic("test failure");
6705 expect(v[91] == 1) catch @panic("test failure");
6706 expect(v[92] == 2) catch @panic("test failure");
6707 expect(v[93] == 3) catch @panic("test failure");
6708 expect(v[94] == 4) catch @panic("test failure");
6709 expect(v[95] == 5) catch @panic("test failure");
6710 expect(v[96] == 6) catch @panic("test failure");
6711 expect(v[97] == 7) catch @panic("test failure");
6712 expect(v[98] == 8) catch @panic("test failure");
6713 expect(v[99] == 9) catch @panic("test failure");
6714 expect(v[100] == 10) catch @panic("test failure");
6715 expect(v[101] == 11) catch @panic("test failure");
6716 expect(v[102] == 12) catch @panic("test failure");
6717 expect(v[103] == 13) catch @panic("test failure");
6718 expect(v[104] == 14) catch @panic("test failure");
6719 expect(v[105] == 15) catch @panic("test failure");
6720 expect(v[106] == 16) catch @panic("test failure");
6721 expect(v[107] == 17) catch @panic("test failure");
6722 expect(v[108] == 18) catch @panic("test failure");
6723 expect(v[109] == 19) catch @panic("test failure");
6724 expect(v[110] == 20) catch @panic("test failure");
6725 expect(v[111] == 21) catch @panic("test failure");
6726 expect(v[112] == 22) catch @panic("test failure");
6727 expect(v[113] == 23) catch @panic("test failure");
6728 expect(v[114] == 24) catch @panic("test failure");
6729 expect(v[115] == 25) catch @panic("test failure");
6730 expect(v[116] == 26) catch @panic("test failure");
6731 expect(v[117] == 27) catch @panic("test failure");
6732 expect(v[118] == 28) catch @panic("test failure");
6733 expect(v[119] == 29) catch @panic("test failure");
6734 expect(v[120] == 30) catch @panic("test failure");
6735 expect(v[121] == 31) catch @panic("test failure");
6736 expect(v[122] == 32) catch @panic("test failure");
6737 expect(v[123] == 33) catch @panic("test failure");
6738 expect(v[124] == 34) catch @panic("test failure");
6739 expect(v[125] == 35) catch @panic("test failure");
6740 expect(v[126] == 36) catch @panic("test failure");
6741 expect(v[127] == 37) catch @panic("test failure");
6742 expect(v[128] == 38) catch @panic("test failure");
6743 expect(v[129] == 39) catch @panic("test failure");
6744 expect(v[130] == 40) catch @panic("test failure");
6745 expect(v[131] == 41) catch @panic("test failure");
6746 expect(v[132] == 42) catch @panic("test failure");
6747 expect(v[133] == 43) catch @panic("test failure");
6748 expect(v[134] == 44) catch @panic("test failure");
6749 expect(v[135] == 45) catch @panic("test failure");
6750 expect(v[136] == 46) catch @panic("test failure");
6751 expect(v[137] == 47) catch @panic("test failure");
6752 expect(v[138] == 48) catch @panic("test failure");
6753 expect(v[139] == 49) catch @panic("test failure");
6754 expect(v[140] == 50) catch @panic("test failure");
6755 expect(v[141] == 51) catch @panic("test failure");
6756 expect(v[142] == 52) catch @panic("test failure");
6757 expect(v[143] == 53) catch @panic("test failure");
6758 expect(v[144] == 54) catch @panic("test failure");
6759 expect(v[145] == 55) catch @panic("test failure");
6760 expect(v[146] == 56) catch @panic("test failure");
6761 expect(v[147] == 57) catch @panic("test failure");
6762 expect(v[148] == 58) catch @panic("test failure");
6763 expect(v[149] == 59) catch @panic("test failure");
6764 expect(v[150] == 60) catch @panic("test failure");
6765 expect(v[151] == 61) catch @panic("test failure");
6766 expect(v[152] == 62) catch @panic("test failure");
6767 expect(v[153] == 63) catch @panic("test failure");
6768 expect(v[154] == 64) catch @panic("test failure");
6769 expect(v[155] == 65) catch @panic("test failure");
6770 expect(v[156] == 66) catch @panic("test failure");
6771 expect(v[157] == 67) catch @panic("test failure");
6772 expect(v[158] == 68) catch @panic("test failure");
6773 expect(v[159] == 69) catch @panic("test failure");
6774 expect(v[160] == 70) catch @panic("test failure");
6775 expect(v[161] == 71) catch @panic("test failure");
6776 expect(v[162] == 72) catch @panic("test failure");
6777 expect(v[163] == 73) catch @panic("test failure");
6778 expect(v[164] == 74) catch @panic("test failure");
6779 expect(v[165] == 75) catch @panic("test failure");
6780 expect(v[166] == 76) catch @panic("test failure");
6781 expect(v[167] == 77) catch @panic("test failure");
6782 expect(v[168] == 78) catch @panic("test failure");
6783 expect(v[169] == 79) catch @panic("test failure");
6784 expect(v[170] == 80) catch @panic("test failure");
6785 expect(v[171] == 81) catch @panic("test failure");
6786 expect(v[172] == 82) catch @panic("test failure");
6787 expect(v[173] == 83) catch @panic("test failure");
6788 expect(v[174] == 84) catch @panic("test failure");
6789 expect(v[175] == 85) catch @panic("test failure");
6790 expect(v[176] == 86) catch @panic("test failure");
6791 expect(v[177] == 87) catch @panic("test failure");
6792 expect(v[178] == 88) catch @panic("test failure");
6793 expect(v[179] == 89) catch @panic("test failure");
6794 expect(v[180] == 90) catch @panic("test failure");
6795 expect(v[181] == 91) catch @panic("test failure");
6796 expect(v[182] == 92) catch @panic("test failure");
6797 expect(v[183] == 93) catch @panic("test failure");
6798 expect(v[184] == 94) catch @panic("test failure");
6799 expect(v[185] == 95) catch @panic("test failure");
6800 expect(v[186] == 96) catch @panic("test failure");
6801 expect(v[187] == 97) catch @panic("test failure");
6802 expect(v[188] == 98) catch @panic("test failure");
6803 expect(v[189] == 99) catch @panic("test failure");
6804 expect(v[190] == 0) catch @panic("test failure");
6805 expect(v[191] == 1) catch @panic("test failure");
6806 expect(v[192] == 2) catch @panic("test failure");
6807 expect(v[193] == 3) catch @panic("test failure");
6808 expect(v[194] == 4) catch @panic("test failure");
6809 expect(v[195] == 5) catch @panic("test failure");
6810 expect(v[196] == 6) catch @panic("test failure");
6811 expect(v[197] == 7) catch @panic("test failure");
6812 expect(v[198] == 8) catch @panic("test failure");
6813 expect(v[199] == 9) catch @panic("test failure");
6814 expect(v[200] == 10) catch @panic("test failure");
6815 expect(v[201] == 11) catch @panic("test failure");
6816 expect(v[202] == 12) catch @panic("test failure");
6817 expect(v[203] == 13) catch @panic("test failure");
6818 expect(v[204] == 14) catch @panic("test failure");
6819 expect(v[205] == 15) catch @panic("test failure");
6820 expect(v[206] == 16) catch @panic("test failure");
6821 expect(v[207] == 17) catch @panic("test failure");
6822 expect(v[208] == 18) catch @panic("test failure");
6823 expect(v[209] == 19) catch @panic("test failure");
6824 expect(v[210] == 20) catch @panic("test failure");
6825 expect(v[211] == 21) catch @panic("test failure");
6826 expect(v[212] == 22) catch @panic("test failure");
6827 expect(v[213] == 23) catch @panic("test failure");
6828 expect(v[214] == 24) catch @panic("test failure");
6829 expect(v[215] == 25) catch @panic("test failure");
6830 expect(v[216] == 26) catch @panic("test failure");
6831 expect(v[217] == 27) catch @panic("test failure");
6832 expect(v[218] == 28) catch @panic("test failure");
6833 expect(v[219] == 29) catch @panic("test failure");
6834 expect(v[220] == 30) catch @panic("test failure");
6835 expect(v[221] == 31) catch @panic("test failure");
6836 expect(v[222] == 32) catch @panic("test failure");
6837 expect(v[223] == 33) catch @panic("test failure");
6838 expect(v[224] == 34) catch @panic("test failure");
6839 expect(v[225] == 35) catch @panic("test failure");
6840 expect(v[226] == 36) catch @panic("test failure");
6841 expect(v[227] == 37) catch @panic("test failure");
6842 expect(v[228] == 38) catch @panic("test failure");
6843 expect(v[229] == 39) catch @panic("test failure");
6844 expect(v[230] == 40) catch @panic("test failure");
6845 expect(v[231] == 41) catch @panic("test failure");
6846 expect(v[232] == 42) catch @panic("test failure");
6847 expect(v[233] == 43) catch @panic("test failure");
6848 expect(v[234] == 44) catch @panic("test failure");
6849 expect(v[235] == 45) catch @panic("test failure");
6850 expect(v[236] == 46) catch @panic("test failure");
6851 expect(v[237] == 47) catch @panic("test failure");
6852 expect(v[238] == 48) catch @panic("test failure");
6853 expect(v[239] == 49) catch @panic("test failure");
6854 expect(v[240] == 50) catch @panic("test failure");
6855 expect(v[241] == 51) catch @panic("test failure");
6856 expect(v[242] == 52) catch @panic("test failure");
6857 expect(v[243] == 53) catch @panic("test failure");
6858 expect(v[244] == 54) catch @panic("test failure");
6859 expect(v[245] == 55) catch @panic("test failure");
6860 expect(v[246] == 56) catch @panic("test failure");
6861 expect(v[247] == 57) catch @panic("test failure");
6862 expect(v[248] == 58) catch @panic("test failure");
6863 expect(v[249] == 59) catch @panic("test failure");
6864 expect(v[250] == 60) catch @panic("test failure");
6865 expect(v[251] == 61) catch @panic("test failure");
6866 expect(v[252] == 62) catch @panic("test failure");
6867 expect(v[253] == 63) catch @panic("test failure");
6868 expect(v[254] == 64) catch @panic("test failure");
6869 expect(v[255] == 65) catch @panic("test failure");
6870 expect(i == 256) catch @panic("test failure");
6871}
6872
6873extern fn c_ret_vector_256_u8() @Vector(256, u8);
6874extern fn c_vector_256_u8(@Vector(256, u8), usize) void;
6875extern fn c_test_vector_256_u8() void;
6876
6877test "@Vector(256, u8)" {
6878 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
6879 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
6880 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
6881 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
6882
6883 const v = c_ret_vector_256_u8();
6884 try expect(v[0] == 66);
6885 try expect(v[1] == 67);
6886 try expect(v[2] == 68);
6887 try expect(v[3] == 69);
6888 try expect(v[4] == 70);
6889 try expect(v[5] == 71);
6890 try expect(v[6] == 72);
6891 try expect(v[7] == 73);
6892 try expect(v[8] == 74);
6893 try expect(v[9] == 75);
6894 try expect(v[10] == 76);
6895 try expect(v[11] == 77);
6896 try expect(v[12] == 78);
6897 try expect(v[13] == 79);
6898 try expect(v[14] == 80);
6899 try expect(v[15] == 81);
6900 try expect(v[16] == 82);
6901 try expect(v[17] == 83);
6902 try expect(v[18] == 84);
6903 try expect(v[19] == 85);
6904 try expect(v[20] == 86);
6905 try expect(v[21] == 87);
6906 try expect(v[22] == 88);
6907 try expect(v[23] == 89);
6908 try expect(v[24] == 90);
6909 try expect(v[25] == 91);
6910 try expect(v[26] == 92);
6911 try expect(v[27] == 93);
6912 try expect(v[28] == 94);
6913 try expect(v[29] == 95);
6914 try expect(v[30] == 96);
6915 try expect(v[31] == 97);
6916 try expect(v[32] == 98);
6917 try expect(v[33] == 99);
6918 try expect(v[34] == 0);
6919 try expect(v[35] == 1);
6920 try expect(v[36] == 2);
6921 try expect(v[37] == 3);
6922 try expect(v[38] == 4);
6923 try expect(v[39] == 5);
6924 try expect(v[40] == 6);
6925 try expect(v[41] == 7);
6926 try expect(v[42] == 8);
6927 try expect(v[43] == 9);
6928 try expect(v[44] == 10);
6929 try expect(v[45] == 11);
6930 try expect(v[46] == 12);
6931 try expect(v[47] == 13);
6932 try expect(v[48] == 14);
6933 try expect(v[49] == 15);
6934 try expect(v[50] == 16);
6935 try expect(v[51] == 17);
6936 try expect(v[52] == 18);
6937 try expect(v[53] == 19);
6938 try expect(v[54] == 20);
6939 try expect(v[55] == 21);
6940 try expect(v[56] == 22);
6941 try expect(v[57] == 23);
6942 try expect(v[58] == 24);
6943 try expect(v[59] == 25);
6944 try expect(v[60] == 26);
6945 try expect(v[61] == 27);
6946 try expect(v[62] == 28);
6947 try expect(v[63] == 29);
6948 try expect(v[64] == 30);
6949 try expect(v[65] == 31);
6950 try expect(v[66] == 32);
6951 try expect(v[67] == 33);
6952 try expect(v[68] == 34);
6953 try expect(v[69] == 35);
6954 try expect(v[70] == 36);
6955 try expect(v[71] == 37);
6956 try expect(v[72] == 38);
6957 try expect(v[73] == 39);
6958 try expect(v[74] == 40);
6959 try expect(v[75] == 41);
6960 try expect(v[76] == 42);
6961 try expect(v[77] == 43);
6962 try expect(v[78] == 44);
6963 try expect(v[79] == 45);
6964 try expect(v[80] == 46);
6965 try expect(v[81] == 47);
6966 try expect(v[82] == 48);
6967 try expect(v[83] == 49);
6968 try expect(v[84] == 50);
6969 try expect(v[85] == 51);
6970 try expect(v[86] == 52);
6971 try expect(v[87] == 53);
6972 try expect(v[88] == 54);
6973 try expect(v[89] == 55);
6974 try expect(v[90] == 56);
6975 try expect(v[91] == 57);
6976 try expect(v[92] == 58);
6977 try expect(v[93] == 59);
6978 try expect(v[94] == 60);
6979 try expect(v[95] == 61);
6980 try expect(v[96] == 62);
6981 try expect(v[97] == 63);
6982 try expect(v[98] == 64);
6983 try expect(v[99] == 65);
6984 try expect(v[100] == 66);
6985 try expect(v[101] == 67);
6986 try expect(v[102] == 68);
6987 try expect(v[103] == 69);
6988 try expect(v[104] == 70);
6989 try expect(v[105] == 71);
6990 try expect(v[106] == 72);
6991 try expect(v[107] == 73);
6992 try expect(v[108] == 74);
6993 try expect(v[109] == 75);
6994 try expect(v[110] == 76);
6995 try expect(v[111] == 77);
6996 try expect(v[112] == 78);
6997 try expect(v[113] == 79);
6998 try expect(v[114] == 80);
6999 try expect(v[115] == 81);
7000 try expect(v[116] == 82);
7001 try expect(v[117] == 83);
7002 try expect(v[118] == 84);
7003 try expect(v[119] == 85);
7004 try expect(v[120] == 86);
7005 try expect(v[121] == 87);
7006 try expect(v[122] == 88);
7007 try expect(v[123] == 89);
7008 try expect(v[124] == 90);
7009 try expect(v[125] == 91);
7010 try expect(v[126] == 92);
7011 try expect(v[127] == 93);
7012 try expect(v[128] == 94);
7013 try expect(v[129] == 95);
7014 try expect(v[130] == 96);
7015 try expect(v[131] == 97);
7016 try expect(v[132] == 98);
7017 try expect(v[133] == 99);
7018 try expect(v[134] == 0);
7019 try expect(v[135] == 1);
7020 try expect(v[136] == 2);
7021 try expect(v[137] == 3);
7022 try expect(v[138] == 4);
7023 try expect(v[139] == 5);
7024 try expect(v[140] == 6);
7025 try expect(v[141] == 7);
7026 try expect(v[142] == 8);
7027 try expect(v[143] == 9);
7028 try expect(v[144] == 10);
7029 try expect(v[145] == 11);
7030 try expect(v[146] == 12);
7031 try expect(v[147] == 13);
7032 try expect(v[148] == 14);
7033 try expect(v[149] == 15);
7034 try expect(v[150] == 16);
7035 try expect(v[151] == 17);
7036 try expect(v[152] == 18);
7037 try expect(v[153] == 19);
7038 try expect(v[154] == 20);
7039 try expect(v[155] == 21);
7040 try expect(v[156] == 22);
7041 try expect(v[157] == 23);
7042 try expect(v[158] == 24);
7043 try expect(v[159] == 25);
7044 try expect(v[160] == 26);
7045 try expect(v[161] == 27);
7046 try expect(v[162] == 28);
7047 try expect(v[163] == 29);
7048 try expect(v[164] == 30);
7049 try expect(v[165] == 31);
7050 try expect(v[166] == 32);
7051 try expect(v[167] == 33);
7052 try expect(v[168] == 34);
7053 try expect(v[169] == 35);
7054 try expect(v[170] == 36);
7055 try expect(v[171] == 37);
7056 try expect(v[172] == 38);
7057 try expect(v[173] == 39);
7058 try expect(v[174] == 40);
7059 try expect(v[175] == 41);
7060 try expect(v[176] == 42);
7061 try expect(v[177] == 43);
7062 try expect(v[178] == 44);
7063 try expect(v[179] == 45);
7064 try expect(v[180] == 46);
7065 try expect(v[181] == 47);
7066 try expect(v[182] == 48);
7067 try expect(v[183] == 49);
7068 try expect(v[184] == 50);
7069 try expect(v[185] == 51);
7070 try expect(v[186] == 52);
7071 try expect(v[187] == 53);
7072 try expect(v[188] == 54);
7073 try expect(v[189] == 55);
7074 try expect(v[190] == 56);
7075 try expect(v[191] == 57);
7076 try expect(v[192] == 58);
7077 try expect(v[193] == 59);
7078 try expect(v[194] == 60);
7079 try expect(v[195] == 61);
7080 try expect(v[196] == 62);
7081 try expect(v[197] == 63);
7082 try expect(v[198] == 64);
7083 try expect(v[199] == 65);
7084 try expect(v[200] == 66);
7085 try expect(v[201] == 67);
7086 try expect(v[202] == 68);
7087 try expect(v[203] == 69);
7088 try expect(v[204] == 70);
7089 try expect(v[205] == 71);
7090 try expect(v[206] == 72);
7091 try expect(v[207] == 73);
7092 try expect(v[208] == 74);
7093 try expect(v[209] == 75);
7094 try expect(v[210] == 76);
7095 try expect(v[211] == 77);
7096 try expect(v[212] == 78);
7097 try expect(v[213] == 79);
7098 try expect(v[214] == 80);
7099 try expect(v[215] == 81);
7100 try expect(v[216] == 82);
7101 try expect(v[217] == 83);
7102 try expect(v[218] == 84);
7103 try expect(v[219] == 85);
7104 try expect(v[220] == 86);
7105 try expect(v[221] == 87);
7106 try expect(v[222] == 88);
7107 try expect(v[223] == 89);
7108 try expect(v[224] == 90);
7109 try expect(v[225] == 91);
7110 try expect(v[226] == 92);
7111 try expect(v[227] == 93);
7112 try expect(v[228] == 94);
7113 try expect(v[229] == 95);
7114 try expect(v[230] == 96);
7115 try expect(v[231] == 97);
7116 try expect(v[232] == 98);
7117 try expect(v[233] == 99);
7118 try expect(v[234] == 0);
7119 try expect(v[235] == 1);
7120 try expect(v[236] == 2);
7121 try expect(v[237] == 3);
7122 try expect(v[238] == 4);
7123 try expect(v[239] == 5);
7124 try expect(v[240] == 6);
7125 try expect(v[241] == 7);
7126 try expect(v[242] == 8);
7127 try expect(v[243] == 9);
7128 try expect(v[244] == 10);
7129 try expect(v[245] == 11);
7130 try expect(v[246] == 12);
7131 try expect(v[247] == 13);
7132 try expect(v[248] == 14);
7133 try expect(v[249] == 15);
7134 try expect(v[250] == 16);
7135 try expect(v[251] == 17);
7136 try expect(v[252] == 18);
7137 try expect(v[253] == 19);
7138 try expect(v[254] == 20);
7139 try expect(v[255] == 21);
7140 c_vector_256_u8(.{
7141 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
7142 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7143 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7144 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7145 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7146 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7147 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7148 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7149 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
7150 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
7151 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
7152 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
7153 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
7154 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
7155 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
7156 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
7157 }, 256);
7158 c_test_vector_256_u8();
7159}
7160
7161export fn zig_ret_vector_384_u8() @Vector(384, u8) {
7162 return .{
7163 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
7164 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
7165 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
7166 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
7167 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7168 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
7169 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
7170 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
7171 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
7172 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
7173 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7174 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7175 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7176 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7177 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7178 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7179 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7180 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
7181 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
7182 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
7183 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
7184 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
7185 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
7186 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
7187 };
7188}
7189export fn zig_vector_384_u8(v: @Vector(384, u8), i: usize) void {
7190 expect(v[0] == 62) catch @panic("test failure");
7191 expect(v[1] == 63) catch @panic("test failure");
7192 expect(v[2] == 64) catch @panic("test failure");
7193 expect(v[3] == 65) catch @panic("test failure");
7194 expect(v[4] == 66) catch @panic("test failure");
7195 expect(v[5] == 67) catch @panic("test failure");
7196 expect(v[6] == 68) catch @panic("test failure");
7197 expect(v[7] == 69) catch @panic("test failure");
7198 expect(v[8] == 70) catch @panic("test failure");
7199 expect(v[9] == 71) catch @panic("test failure");
7200 expect(v[10] == 72) catch @panic("test failure");
7201 expect(v[11] == 73) catch @panic("test failure");
7202 expect(v[12] == 74) catch @panic("test failure");
7203 expect(v[13] == 75) catch @panic("test failure");
7204 expect(v[14] == 76) catch @panic("test failure");
7205 expect(v[15] == 77) catch @panic("test failure");
7206 expect(v[16] == 78) catch @panic("test failure");
7207 expect(v[17] == 79) catch @panic("test failure");
7208 expect(v[18] == 80) catch @panic("test failure");
7209 expect(v[19] == 81) catch @panic("test failure");
7210 expect(v[20] == 82) catch @panic("test failure");
7211 expect(v[21] == 83) catch @panic("test failure");
7212 expect(v[22] == 84) catch @panic("test failure");
7213 expect(v[23] == 85) catch @panic("test failure");
7214 expect(v[24] == 86) catch @panic("test failure");
7215 expect(v[25] == 87) catch @panic("test failure");
7216 expect(v[26] == 88) catch @panic("test failure");
7217 expect(v[27] == 89) catch @panic("test failure");
7218 expect(v[28] == 90) catch @panic("test failure");
7219 expect(v[29] == 91) catch @panic("test failure");
7220 expect(v[30] == 92) catch @panic("test failure");
7221 expect(v[31] == 93) catch @panic("test failure");
7222 expect(v[32] == 94) catch @panic("test failure");
7223 expect(v[33] == 95) catch @panic("test failure");
7224 expect(v[34] == 96) catch @panic("test failure");
7225 expect(v[35] == 97) catch @panic("test failure");
7226 expect(v[36] == 98) catch @panic("test failure");
7227 expect(v[37] == 99) catch @panic("test failure");
7228 expect(v[38] == 0) catch @panic("test failure");
7229 expect(v[39] == 1) catch @panic("test failure");
7230 expect(v[40] == 2) catch @panic("test failure");
7231 expect(v[41] == 3) catch @panic("test failure");
7232 expect(v[42] == 4) catch @panic("test failure");
7233 expect(v[43] == 5) catch @panic("test failure");
7234 expect(v[44] == 6) catch @panic("test failure");
7235 expect(v[45] == 7) catch @panic("test failure");
7236 expect(v[46] == 8) catch @panic("test failure");
7237 expect(v[47] == 9) catch @panic("test failure");
7238 expect(v[48] == 10) catch @panic("test failure");
7239 expect(v[49] == 11) catch @panic("test failure");
7240 expect(v[50] == 12) catch @panic("test failure");
7241 expect(v[51] == 13) catch @panic("test failure");
7242 expect(v[52] == 14) catch @panic("test failure");
7243 expect(v[53] == 15) catch @panic("test failure");
7244 expect(v[54] == 16) catch @panic("test failure");
7245 expect(v[55] == 17) catch @panic("test failure");
7246 expect(v[56] == 18) catch @panic("test failure");
7247 expect(v[57] == 19) catch @panic("test failure");
7248 expect(v[58] == 20) catch @panic("test failure");
7249 expect(v[59] == 21) catch @panic("test failure");
7250 expect(v[60] == 22) catch @panic("test failure");
7251 expect(v[61] == 23) catch @panic("test failure");
7252 expect(v[62] == 24) catch @panic("test failure");
7253 expect(v[63] == 25) catch @panic("test failure");
7254 expect(v[64] == 26) catch @panic("test failure");
7255 expect(v[65] == 27) catch @panic("test failure");
7256 expect(v[66] == 28) catch @panic("test failure");
7257 expect(v[67] == 29) catch @panic("test failure");
7258 expect(v[68] == 30) catch @panic("test failure");
7259 expect(v[69] == 31) catch @panic("test failure");
7260 expect(v[70] == 32) catch @panic("test failure");
7261 expect(v[71] == 33) catch @panic("test failure");
7262 expect(v[72] == 34) catch @panic("test failure");
7263 expect(v[73] == 35) catch @panic("test failure");
7264 expect(v[74] == 36) catch @panic("test failure");
7265 expect(v[75] == 37) catch @panic("test failure");
7266 expect(v[76] == 38) catch @panic("test failure");
7267 expect(v[77] == 39) catch @panic("test failure");
7268 expect(v[78] == 40) catch @panic("test failure");
7269 expect(v[79] == 41) catch @panic("test failure");
7270 expect(v[80] == 42) catch @panic("test failure");
7271 expect(v[81] == 43) catch @panic("test failure");
7272 expect(v[82] == 44) catch @panic("test failure");
7273 expect(v[83] == 45) catch @panic("test failure");
7274 expect(v[84] == 46) catch @panic("test failure");
7275 expect(v[85] == 47) catch @panic("test failure");
7276 expect(v[86] == 48) catch @panic("test failure");
7277 expect(v[87] == 49) catch @panic("test failure");
7278 expect(v[88] == 50) catch @panic("test failure");
7279 expect(v[89] == 51) catch @panic("test failure");
7280 expect(v[90] == 52) catch @panic("test failure");
7281 expect(v[91] == 53) catch @panic("test failure");
7282 expect(v[92] == 54) catch @panic("test failure");
7283 expect(v[93] == 55) catch @panic("test failure");
7284 expect(v[94] == 56) catch @panic("test failure");
7285 expect(v[95] == 57) catch @panic("test failure");
7286 expect(v[96] == 58) catch @panic("test failure");
7287 expect(v[97] == 59) catch @panic("test failure");
7288 expect(v[98] == 60) catch @panic("test failure");
7289 expect(v[99] == 61) catch @panic("test failure");
7290 expect(v[100] == 62) catch @panic("test failure");
7291 expect(v[101] == 63) catch @panic("test failure");
7292 expect(v[102] == 64) catch @panic("test failure");
7293 expect(v[103] == 65) catch @panic("test failure");
7294 expect(v[104] == 66) catch @panic("test failure");
7295 expect(v[105] == 67) catch @panic("test failure");
7296 expect(v[106] == 68) catch @panic("test failure");
7297 expect(v[107] == 69) catch @panic("test failure");
7298 expect(v[108] == 70) catch @panic("test failure");
7299 expect(v[109] == 71) catch @panic("test failure");
7300 expect(v[110] == 72) catch @panic("test failure");
7301 expect(v[111] == 73) catch @panic("test failure");
7302 expect(v[112] == 74) catch @panic("test failure");
7303 expect(v[113] == 75) catch @panic("test failure");
7304 expect(v[114] == 76) catch @panic("test failure");
7305 expect(v[115] == 77) catch @panic("test failure");
7306 expect(v[116] == 78) catch @panic("test failure");
7307 expect(v[117] == 79) catch @panic("test failure");
7308 expect(v[118] == 80) catch @panic("test failure");
7309 expect(v[119] == 81) catch @panic("test failure");
7310 expect(v[120] == 82) catch @panic("test failure");
7311 expect(v[121] == 83) catch @panic("test failure");
7312 expect(v[122] == 84) catch @panic("test failure");
7313 expect(v[123] == 85) catch @panic("test failure");
7314 expect(v[124] == 86) catch @panic("test failure");
7315 expect(v[125] == 87) catch @panic("test failure");
7316 expect(v[126] == 88) catch @panic("test failure");
7317 expect(v[127] == 89) catch @panic("test failure");
7318 expect(v[128] == 90) catch @panic("test failure");
7319 expect(v[129] == 91) catch @panic("test failure");
7320 expect(v[130] == 92) catch @panic("test failure");
7321 expect(v[131] == 93) catch @panic("test failure");
7322 expect(v[132] == 94) catch @panic("test failure");
7323 expect(v[133] == 95) catch @panic("test failure");
7324 expect(v[134] == 96) catch @panic("test failure");
7325 expect(v[135] == 97) catch @panic("test failure");
7326 expect(v[136] == 98) catch @panic("test failure");
7327 expect(v[137] == 99) catch @panic("test failure");
7328 expect(v[138] == 0) catch @panic("test failure");
7329 expect(v[139] == 1) catch @panic("test failure");
7330 expect(v[140] == 2) catch @panic("test failure");
7331 expect(v[141] == 3) catch @panic("test failure");
7332 expect(v[142] == 4) catch @panic("test failure");
7333 expect(v[143] == 5) catch @panic("test failure");
7334 expect(v[144] == 6) catch @panic("test failure");
7335 expect(v[145] == 7) catch @panic("test failure");
7336 expect(v[146] == 8) catch @panic("test failure");
7337 expect(v[147] == 9) catch @panic("test failure");
7338 expect(v[148] == 10) catch @panic("test failure");
7339 expect(v[149] == 11) catch @panic("test failure");
7340 expect(v[150] == 12) catch @panic("test failure");
7341 expect(v[151] == 13) catch @panic("test failure");
7342 expect(v[152] == 14) catch @panic("test failure");
7343 expect(v[153] == 15) catch @panic("test failure");
7344 expect(v[154] == 16) catch @panic("test failure");
7345 expect(v[155] == 17) catch @panic("test failure");
7346 expect(v[156] == 18) catch @panic("test failure");
7347 expect(v[157] == 19) catch @panic("test failure");
7348 expect(v[158] == 20) catch @panic("test failure");
7349 expect(v[159] == 21) catch @panic("test failure");
7350 expect(v[160] == 22) catch @panic("test failure");
7351 expect(v[161] == 23) catch @panic("test failure");
7352 expect(v[162] == 24) catch @panic("test failure");
7353 expect(v[163] == 25) catch @panic("test failure");
7354 expect(v[164] == 26) catch @panic("test failure");
7355 expect(v[165] == 27) catch @panic("test failure");
7356 expect(v[166] == 28) catch @panic("test failure");
7357 expect(v[167] == 29) catch @panic("test failure");
7358 expect(v[168] == 30) catch @panic("test failure");
7359 expect(v[169] == 31) catch @panic("test failure");
7360 expect(v[170] == 32) catch @panic("test failure");
7361 expect(v[171] == 33) catch @panic("test failure");
7362 expect(v[172] == 34) catch @panic("test failure");
7363 expect(v[173] == 35) catch @panic("test failure");
7364 expect(v[174] == 36) catch @panic("test failure");
7365 expect(v[175] == 37) catch @panic("test failure");
7366 expect(v[176] == 38) catch @panic("test failure");
7367 expect(v[177] == 39) catch @panic("test failure");
7368 expect(v[178] == 40) catch @panic("test failure");
7369 expect(v[179] == 41) catch @panic("test failure");
7370 expect(v[180] == 42) catch @panic("test failure");
7371 expect(v[181] == 43) catch @panic("test failure");
7372 expect(v[182] == 44) catch @panic("test failure");
7373 expect(v[183] == 45) catch @panic("test failure");
7374 expect(v[184] == 46) catch @panic("test failure");
7375 expect(v[185] == 47) catch @panic("test failure");
7376 expect(v[186] == 48) catch @panic("test failure");
7377 expect(v[187] == 49) catch @panic("test failure");
7378 expect(v[188] == 50) catch @panic("test failure");
7379 expect(v[189] == 51) catch @panic("test failure");
7380 expect(v[190] == 52) catch @panic("test failure");
7381 expect(v[191] == 53) catch @panic("test failure");
7382 expect(v[192] == 54) catch @panic("test failure");
7383 expect(v[193] == 55) catch @panic("test failure");
7384 expect(v[194] == 56) catch @panic("test failure");
7385 expect(v[195] == 57) catch @panic("test failure");
7386 expect(v[196] == 58) catch @panic("test failure");
7387 expect(v[197] == 59) catch @panic("test failure");
7388 expect(v[198] == 60) catch @panic("test failure");
7389 expect(v[199] == 61) catch @panic("test failure");
7390 expect(v[200] == 62) catch @panic("test failure");
7391 expect(v[201] == 63) catch @panic("test failure");
7392 expect(v[202] == 64) catch @panic("test failure");
7393 expect(v[203] == 65) catch @panic("test failure");
7394 expect(v[204] == 66) catch @panic("test failure");
7395 expect(v[205] == 67) catch @panic("test failure");
7396 expect(v[206] == 68) catch @panic("test failure");
7397 expect(v[207] == 69) catch @panic("test failure");
7398 expect(v[208] == 70) catch @panic("test failure");
7399 expect(v[209] == 71) catch @panic("test failure");
7400 expect(v[210] == 72) catch @panic("test failure");
7401 expect(v[211] == 73) catch @panic("test failure");
7402 expect(v[212] == 74) catch @panic("test failure");
7403 expect(v[213] == 75) catch @panic("test failure");
7404 expect(v[214] == 76) catch @panic("test failure");
7405 expect(v[215] == 77) catch @panic("test failure");
7406 expect(v[216] == 78) catch @panic("test failure");
7407 expect(v[217] == 79) catch @panic("test failure");
7408 expect(v[218] == 80) catch @panic("test failure");
7409 expect(v[219] == 81) catch @panic("test failure");
7410 expect(v[220] == 82) catch @panic("test failure");
7411 expect(v[221] == 83) catch @panic("test failure");
7412 expect(v[222] == 84) catch @panic("test failure");
7413 expect(v[223] == 85) catch @panic("test failure");
7414 expect(v[224] == 86) catch @panic("test failure");
7415 expect(v[225] == 87) catch @panic("test failure");
7416 expect(v[226] == 88) catch @panic("test failure");
7417 expect(v[227] == 89) catch @panic("test failure");
7418 expect(v[228] == 90) catch @panic("test failure");
7419 expect(v[229] == 91) catch @panic("test failure");
7420 expect(v[230] == 92) catch @panic("test failure");
7421 expect(v[231] == 93) catch @panic("test failure");
7422 expect(v[232] == 94) catch @panic("test failure");
7423 expect(v[233] == 95) catch @panic("test failure");
7424 expect(v[234] == 96) catch @panic("test failure");
7425 expect(v[235] == 97) catch @panic("test failure");
7426 expect(v[236] == 98) catch @panic("test failure");
7427 expect(v[237] == 99) catch @panic("test failure");
7428 expect(v[238] == 0) catch @panic("test failure");
7429 expect(v[239] == 1) catch @panic("test failure");
7430 expect(v[240] == 2) catch @panic("test failure");
7431 expect(v[241] == 3) catch @panic("test failure");
7432 expect(v[242] == 4) catch @panic("test failure");
7433 expect(v[243] == 5) catch @panic("test failure");
7434 expect(v[244] == 6) catch @panic("test failure");
7435 expect(v[245] == 7) catch @panic("test failure");
7436 expect(v[246] == 8) catch @panic("test failure");
7437 expect(v[247] == 9) catch @panic("test failure");
7438 expect(v[248] == 10) catch @panic("test failure");
7439 expect(v[249] == 11) catch @panic("test failure");
7440 expect(v[250] == 12) catch @panic("test failure");
7441 expect(v[251] == 13) catch @panic("test failure");
7442 expect(v[252] == 14) catch @panic("test failure");
7443 expect(v[253] == 15) catch @panic("test failure");
7444 expect(v[254] == 16) catch @panic("test failure");
7445 expect(v[255] == 17) catch @panic("test failure");
7446 expect(v[256] == 18) catch @panic("test failure");
7447 expect(v[257] == 19) catch @panic("test failure");
7448 expect(v[258] == 20) catch @panic("test failure");
7449 expect(v[259] == 21) catch @panic("test failure");
7450 expect(v[260] == 22) catch @panic("test failure");
7451 expect(v[261] == 23) catch @panic("test failure");
7452 expect(v[262] == 24) catch @panic("test failure");
7453 expect(v[263] == 25) catch @panic("test failure");
7454 expect(v[264] == 26) catch @panic("test failure");
7455 expect(v[265] == 27) catch @panic("test failure");
7456 expect(v[266] == 28) catch @panic("test failure");
7457 expect(v[267] == 29) catch @panic("test failure");
7458 expect(v[268] == 30) catch @panic("test failure");
7459 expect(v[269] == 31) catch @panic("test failure");
7460 expect(v[270] == 32) catch @panic("test failure");
7461 expect(v[271] == 33) catch @panic("test failure");
7462 expect(v[272] == 34) catch @panic("test failure");
7463 expect(v[273] == 35) catch @panic("test failure");
7464 expect(v[274] == 36) catch @panic("test failure");
7465 expect(v[275] == 37) catch @panic("test failure");
7466 expect(v[276] == 38) catch @panic("test failure");
7467 expect(v[277] == 39) catch @panic("test failure");
7468 expect(v[278] == 40) catch @panic("test failure");
7469 expect(v[279] == 41) catch @panic("test failure");
7470 expect(v[280] == 42) catch @panic("test failure");
7471 expect(v[281] == 43) catch @panic("test failure");
7472 expect(v[282] == 44) catch @panic("test failure");
7473 expect(v[283] == 45) catch @panic("test failure");
7474 expect(v[284] == 46) catch @panic("test failure");
7475 expect(v[285] == 47) catch @panic("test failure");
7476 expect(v[286] == 48) catch @panic("test failure");
7477 expect(v[287] == 49) catch @panic("test failure");
7478 expect(v[288] == 50) catch @panic("test failure");
7479 expect(v[289] == 51) catch @panic("test failure");
7480 expect(v[290] == 52) catch @panic("test failure");
7481 expect(v[291] == 53) catch @panic("test failure");
7482 expect(v[292] == 54) catch @panic("test failure");
7483 expect(v[293] == 55) catch @panic("test failure");
7484 expect(v[294] == 56) catch @panic("test failure");
7485 expect(v[295] == 57) catch @panic("test failure");
7486 expect(v[296] == 58) catch @panic("test failure");
7487 expect(v[297] == 59) catch @panic("test failure");
7488 expect(v[298] == 60) catch @panic("test failure");
7489 expect(v[299] == 61) catch @panic("test failure");
7490 expect(v[300] == 62) catch @panic("test failure");
7491 expect(v[301] == 63) catch @panic("test failure");
7492 expect(v[302] == 64) catch @panic("test failure");
7493 expect(v[303] == 65) catch @panic("test failure");
7494 expect(v[304] == 66) catch @panic("test failure");
7495 expect(v[305] == 67) catch @panic("test failure");
7496 expect(v[306] == 68) catch @panic("test failure");
7497 expect(v[307] == 69) catch @panic("test failure");
7498 expect(v[308] == 70) catch @panic("test failure");
7499 expect(v[309] == 71) catch @panic("test failure");
7500 expect(v[310] == 72) catch @panic("test failure");
7501 expect(v[311] == 73) catch @panic("test failure");
7502 expect(v[312] == 74) catch @panic("test failure");
7503 expect(v[313] == 75) catch @panic("test failure");
7504 expect(v[314] == 76) catch @panic("test failure");
7505 expect(v[315] == 77) catch @panic("test failure");
7506 expect(v[316] == 78) catch @panic("test failure");
7507 expect(v[317] == 79) catch @panic("test failure");
7508 expect(v[318] == 80) catch @panic("test failure");
7509 expect(v[319] == 81) catch @panic("test failure");
7510 expect(v[320] == 82) catch @panic("test failure");
7511 expect(v[321] == 83) catch @panic("test failure");
7512 expect(v[322] == 84) catch @panic("test failure");
7513 expect(v[323] == 85) catch @panic("test failure");
7514 expect(v[324] == 86) catch @panic("test failure");
7515 expect(v[325] == 87) catch @panic("test failure");
7516 expect(v[326] == 88) catch @panic("test failure");
7517 expect(v[327] == 89) catch @panic("test failure");
7518 expect(v[328] == 90) catch @panic("test failure");
7519 expect(v[329] == 91) catch @panic("test failure");
7520 expect(v[330] == 92) catch @panic("test failure");
7521 expect(v[331] == 93) catch @panic("test failure");
7522 expect(v[332] == 94) catch @panic("test failure");
7523 expect(v[333] == 95) catch @panic("test failure");
7524 expect(v[334] == 96) catch @panic("test failure");
7525 expect(v[335] == 97) catch @panic("test failure");
7526 expect(v[336] == 98) catch @panic("test failure");
7527 expect(v[337] == 99) catch @panic("test failure");
7528 expect(v[338] == 0) catch @panic("test failure");
7529 expect(v[339] == 1) catch @panic("test failure");
7530 expect(v[340] == 2) catch @panic("test failure");
7531 expect(v[341] == 3) catch @panic("test failure");
7532 expect(v[342] == 4) catch @panic("test failure");
7533 expect(v[343] == 5) catch @panic("test failure");
7534 expect(v[344] == 6) catch @panic("test failure");
7535 expect(v[345] == 7) catch @panic("test failure");
7536 expect(v[346] == 8) catch @panic("test failure");
7537 expect(v[347] == 9) catch @panic("test failure");
7538 expect(v[348] == 10) catch @panic("test failure");
7539 expect(v[349] == 11) catch @panic("test failure");
7540 expect(v[350] == 12) catch @panic("test failure");
7541 expect(v[351] == 13) catch @panic("test failure");
7542 expect(v[352] == 14) catch @panic("test failure");
7543 expect(v[353] == 15) catch @panic("test failure");
7544 expect(v[354] == 16) catch @panic("test failure");
7545 expect(v[355] == 17) catch @panic("test failure");
7546 expect(v[356] == 18) catch @panic("test failure");
7547 expect(v[357] == 19) catch @panic("test failure");
7548 expect(v[358] == 20) catch @panic("test failure");
7549 expect(v[359] == 21) catch @panic("test failure");
7550 expect(v[360] == 22) catch @panic("test failure");
7551 expect(v[361] == 23) catch @panic("test failure");
7552 expect(v[362] == 24) catch @panic("test failure");
7553 expect(v[363] == 25) catch @panic("test failure");
7554 expect(v[364] == 26) catch @panic("test failure");
7555 expect(v[365] == 27) catch @panic("test failure");
7556 expect(v[366] == 28) catch @panic("test failure");
7557 expect(v[367] == 29) catch @panic("test failure");
7558 expect(v[368] == 30) catch @panic("test failure");
7559 expect(v[369] == 31) catch @panic("test failure");
7560 expect(v[370] == 32) catch @panic("test failure");
7561 expect(v[371] == 33) catch @panic("test failure");
7562 expect(v[372] == 34) catch @panic("test failure");
7563 expect(v[373] == 35) catch @panic("test failure");
7564 expect(v[374] == 36) catch @panic("test failure");
7565 expect(v[375] == 37) catch @panic("test failure");
7566 expect(v[376] == 38) catch @panic("test failure");
7567 expect(v[377] == 39) catch @panic("test failure");
7568 expect(v[378] == 40) catch @panic("test failure");
7569 expect(v[379] == 41) catch @panic("test failure");
7570 expect(v[380] == 42) catch @panic("test failure");
7571 expect(v[381] == 43) catch @panic("test failure");
7572 expect(v[382] == 44) catch @panic("test failure");
7573 expect(v[383] == 45) catch @panic("test failure");
7574 expect(i == 384) catch @panic("test failure");
7575}
7576
7577extern fn c_ret_vector_384_u8() @Vector(384, u8);
7578extern fn c_vector_384_u8(@Vector(384, u8), usize) void;
7579extern fn c_test_vector_384_u8() void;
7580
7581test "@Vector(384, u8)" {
7582 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
7583 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
7584 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
7585 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
7586
7587 const v = c_ret_vector_384_u8();
7588 try expect(v[0] == 46);
7589 try expect(v[1] == 47);
7590 try expect(v[2] == 48);
7591 try expect(v[3] == 49);
7592 try expect(v[4] == 50);
7593 try expect(v[5] == 51);
7594 try expect(v[6] == 52);
7595 try expect(v[7] == 53);
7596 try expect(v[8] == 54);
7597 try expect(v[9] == 55);
7598 try expect(v[10] == 56);
7599 try expect(v[11] == 57);
7600 try expect(v[12] == 58);
7601 try expect(v[13] == 59);
7602 try expect(v[14] == 60);
7603 try expect(v[15] == 61);
7604 try expect(v[16] == 62);
7605 try expect(v[17] == 63);
7606 try expect(v[18] == 64);
7607 try expect(v[19] == 65);
7608 try expect(v[20] == 66);
7609 try expect(v[21] == 67);
7610 try expect(v[22] == 68);
7611 try expect(v[23] == 69);
7612 try expect(v[24] == 70);
7613 try expect(v[25] == 71);
7614 try expect(v[26] == 72);
7615 try expect(v[27] == 73);
7616 try expect(v[28] == 74);
7617 try expect(v[29] == 75);
7618 try expect(v[30] == 76);
7619 try expect(v[31] == 77);
7620 try expect(v[32] == 78);
7621 try expect(v[33] == 79);
7622 try expect(v[34] == 80);
7623 try expect(v[35] == 81);
7624 try expect(v[36] == 82);
7625 try expect(v[37] == 83);
7626 try expect(v[38] == 84);
7627 try expect(v[39] == 85);
7628 try expect(v[40] == 86);
7629 try expect(v[41] == 87);
7630 try expect(v[42] == 88);
7631 try expect(v[43] == 89);
7632 try expect(v[44] == 90);
7633 try expect(v[45] == 91);
7634 try expect(v[46] == 92);
7635 try expect(v[47] == 93);
7636 try expect(v[48] == 94);
7637 try expect(v[49] == 95);
7638 try expect(v[50] == 96);
7639 try expect(v[51] == 97);
7640 try expect(v[52] == 98);
7641 try expect(v[53] == 99);
7642 try expect(v[54] == 0);
7643 try expect(v[55] == 1);
7644 try expect(v[56] == 2);
7645 try expect(v[57] == 3);
7646 try expect(v[58] == 4);
7647 try expect(v[59] == 5);
7648 try expect(v[60] == 6);
7649 try expect(v[61] == 7);
7650 try expect(v[62] == 8);
7651 try expect(v[63] == 9);
7652 try expect(v[64] == 10);
7653 try expect(v[65] == 11);
7654 try expect(v[66] == 12);
7655 try expect(v[67] == 13);
7656 try expect(v[68] == 14);
7657 try expect(v[69] == 15);
7658 try expect(v[70] == 16);
7659 try expect(v[71] == 17);
7660 try expect(v[72] == 18);
7661 try expect(v[73] == 19);
7662 try expect(v[74] == 20);
7663 try expect(v[75] == 21);
7664 try expect(v[76] == 22);
7665 try expect(v[77] == 23);
7666 try expect(v[78] == 24);
7667 try expect(v[79] == 25);
7668 try expect(v[80] == 26);
7669 try expect(v[81] == 27);
7670 try expect(v[82] == 28);
7671 try expect(v[83] == 29);
7672 try expect(v[84] == 30);
7673 try expect(v[85] == 31);
7674 try expect(v[86] == 32);
7675 try expect(v[87] == 33);
7676 try expect(v[88] == 34);
7677 try expect(v[89] == 35);
7678 try expect(v[90] == 36);
7679 try expect(v[91] == 37);
7680 try expect(v[92] == 38);
7681 try expect(v[93] == 39);
7682 try expect(v[94] == 40);
7683 try expect(v[95] == 41);
7684 try expect(v[96] == 42);
7685 try expect(v[97] == 43);
7686 try expect(v[98] == 44);
7687 try expect(v[99] == 45);
7688 try expect(v[100] == 46);
7689 try expect(v[101] == 47);
7690 try expect(v[102] == 48);
7691 try expect(v[103] == 49);
7692 try expect(v[104] == 50);
7693 try expect(v[105] == 51);
7694 try expect(v[106] == 52);
7695 try expect(v[107] == 53);
7696 try expect(v[108] == 54);
7697 try expect(v[109] == 55);
7698 try expect(v[110] == 56);
7699 try expect(v[111] == 57);
7700 try expect(v[112] == 58);
7701 try expect(v[113] == 59);
7702 try expect(v[114] == 60);
7703 try expect(v[115] == 61);
7704 try expect(v[116] == 62);
7705 try expect(v[117] == 63);
7706 try expect(v[118] == 64);
7707 try expect(v[119] == 65);
7708 try expect(v[120] == 66);
7709 try expect(v[121] == 67);
7710 try expect(v[122] == 68);
7711 try expect(v[123] == 69);
7712 try expect(v[124] == 70);
7713 try expect(v[125] == 71);
7714 try expect(v[126] == 72);
7715 try expect(v[127] == 73);
7716 try expect(v[128] == 74);
7717 try expect(v[129] == 75);
7718 try expect(v[130] == 76);
7719 try expect(v[131] == 77);
7720 try expect(v[132] == 78);
7721 try expect(v[133] == 79);
7722 try expect(v[134] == 80);
7723 try expect(v[135] == 81);
7724 try expect(v[136] == 82);
7725 try expect(v[137] == 83);
7726 try expect(v[138] == 84);
7727 try expect(v[139] == 85);
7728 try expect(v[140] == 86);
7729 try expect(v[141] == 87);
7730 try expect(v[142] == 88);
7731 try expect(v[143] == 89);
7732 try expect(v[144] == 90);
7733 try expect(v[145] == 91);
7734 try expect(v[146] == 92);
7735 try expect(v[147] == 93);
7736 try expect(v[148] == 94);
7737 try expect(v[149] == 95);
7738 try expect(v[150] == 96);
7739 try expect(v[151] == 97);
7740 try expect(v[152] == 98);
7741 try expect(v[153] == 99);
7742 try expect(v[154] == 0);
7743 try expect(v[155] == 1);
7744 try expect(v[156] == 2);
7745 try expect(v[157] == 3);
7746 try expect(v[158] == 4);
7747 try expect(v[159] == 5);
7748 try expect(v[160] == 6);
7749 try expect(v[161] == 7);
7750 try expect(v[162] == 8);
7751 try expect(v[163] == 9);
7752 try expect(v[164] == 10);
7753 try expect(v[165] == 11);
7754 try expect(v[166] == 12);
7755 try expect(v[167] == 13);
7756 try expect(v[168] == 14);
7757 try expect(v[169] == 15);
7758 try expect(v[170] == 16);
7759 try expect(v[171] == 17);
7760 try expect(v[172] == 18);
7761 try expect(v[173] == 19);
7762 try expect(v[174] == 20);
7763 try expect(v[175] == 21);
7764 try expect(v[176] == 22);
7765 try expect(v[177] == 23);
7766 try expect(v[178] == 24);
7767 try expect(v[179] == 25);
7768 try expect(v[180] == 26);
7769 try expect(v[181] == 27);
7770 try expect(v[182] == 28);
7771 try expect(v[183] == 29);
7772 try expect(v[184] == 30);
7773 try expect(v[185] == 31);
7774 try expect(v[186] == 32);
7775 try expect(v[187] == 33);
7776 try expect(v[188] == 34);
7777 try expect(v[189] == 35);
7778 try expect(v[190] == 36);
7779 try expect(v[191] == 37);
7780 try expect(v[192] == 38);
7781 try expect(v[193] == 39);
7782 try expect(v[194] == 40);
7783 try expect(v[195] == 41);
7784 try expect(v[196] == 42);
7785 try expect(v[197] == 43);
7786 try expect(v[198] == 44);
7787 try expect(v[199] == 45);
7788 try expect(v[200] == 46);
7789 try expect(v[201] == 47);
7790 try expect(v[202] == 48);
7791 try expect(v[203] == 49);
7792 try expect(v[204] == 50);
7793 try expect(v[205] == 51);
7794 try expect(v[206] == 52);
7795 try expect(v[207] == 53);
7796 try expect(v[208] == 54);
7797 try expect(v[209] == 55);
7798 try expect(v[210] == 56);
7799 try expect(v[211] == 57);
7800 try expect(v[212] == 58);
7801 try expect(v[213] == 59);
7802 try expect(v[214] == 60);
7803 try expect(v[215] == 61);
7804 try expect(v[216] == 62);
7805 try expect(v[217] == 63);
7806 try expect(v[218] == 64);
7807 try expect(v[219] == 65);
7808 try expect(v[220] == 66);
7809 try expect(v[221] == 67);
7810 try expect(v[222] == 68);
7811 try expect(v[223] == 69);
7812 try expect(v[224] == 70);
7813 try expect(v[225] == 71);
7814 try expect(v[226] == 72);
7815 try expect(v[227] == 73);
7816 try expect(v[228] == 74);
7817 try expect(v[229] == 75);
7818 try expect(v[230] == 76);
7819 try expect(v[231] == 77);
7820 try expect(v[232] == 78);
7821 try expect(v[233] == 79);
7822 try expect(v[234] == 80);
7823 try expect(v[235] == 81);
7824 try expect(v[236] == 82);
7825 try expect(v[237] == 83);
7826 try expect(v[238] == 84);
7827 try expect(v[239] == 85);
7828 try expect(v[240] == 86);
7829 try expect(v[241] == 87);
7830 try expect(v[242] == 88);
7831 try expect(v[243] == 89);
7832 try expect(v[244] == 90);
7833 try expect(v[245] == 91);
7834 try expect(v[246] == 92);
7835 try expect(v[247] == 93);
7836 try expect(v[248] == 94);
7837 try expect(v[249] == 95);
7838 try expect(v[250] == 96);
7839 try expect(v[251] == 97);
7840 try expect(v[252] == 98);
7841 try expect(v[253] == 99);
7842 try expect(v[254] == 0);
7843 try expect(v[255] == 1);
7844 try expect(v[256] == 2);
7845 try expect(v[257] == 3);
7846 try expect(v[258] == 4);
7847 try expect(v[259] == 5);
7848 try expect(v[260] == 6);
7849 try expect(v[261] == 7);
7850 try expect(v[262] == 8);
7851 try expect(v[263] == 9);
7852 try expect(v[264] == 10);
7853 try expect(v[265] == 11);
7854 try expect(v[266] == 12);
7855 try expect(v[267] == 13);
7856 try expect(v[268] == 14);
7857 try expect(v[269] == 15);
7858 try expect(v[270] == 16);
7859 try expect(v[271] == 17);
7860 try expect(v[272] == 18);
7861 try expect(v[273] == 19);
7862 try expect(v[274] == 20);
7863 try expect(v[275] == 21);
7864 try expect(v[276] == 22);
7865 try expect(v[277] == 23);
7866 try expect(v[278] == 24);
7867 try expect(v[279] == 25);
7868 try expect(v[280] == 26);
7869 try expect(v[281] == 27);
7870 try expect(v[282] == 28);
7871 try expect(v[283] == 29);
7872 try expect(v[284] == 30);
7873 try expect(v[285] == 31);
7874 try expect(v[286] == 32);
7875 try expect(v[287] == 33);
7876 try expect(v[288] == 34);
7877 try expect(v[289] == 35);
7878 try expect(v[290] == 36);
7879 try expect(v[291] == 37);
7880 try expect(v[292] == 38);
7881 try expect(v[293] == 39);
7882 try expect(v[294] == 40);
7883 try expect(v[295] == 41);
7884 try expect(v[296] == 42);
7885 try expect(v[297] == 43);
7886 try expect(v[298] == 44);
7887 try expect(v[299] == 45);
7888 try expect(v[300] == 46);
7889 try expect(v[301] == 47);
7890 try expect(v[302] == 48);
7891 try expect(v[303] == 49);
7892 try expect(v[304] == 50);
7893 try expect(v[305] == 51);
7894 try expect(v[306] == 52);
7895 try expect(v[307] == 53);
7896 try expect(v[308] == 54);
7897 try expect(v[309] == 55);
7898 try expect(v[310] == 56);
7899 try expect(v[311] == 57);
7900 try expect(v[312] == 58);
7901 try expect(v[313] == 59);
7902 try expect(v[314] == 60);
7903 try expect(v[315] == 61);
7904 try expect(v[316] == 62);
7905 try expect(v[317] == 63);
7906 try expect(v[318] == 64);
7907 try expect(v[319] == 65);
7908 try expect(v[320] == 66);
7909 try expect(v[321] == 67);
7910 try expect(v[322] == 68);
7911 try expect(v[323] == 69);
7912 try expect(v[324] == 70);
7913 try expect(v[325] == 71);
7914 try expect(v[326] == 72);
7915 try expect(v[327] == 73);
7916 try expect(v[328] == 74);
7917 try expect(v[329] == 75);
7918 try expect(v[330] == 76);
7919 try expect(v[331] == 77);
7920 try expect(v[332] == 78);
7921 try expect(v[333] == 79);
7922 try expect(v[334] == 80);
7923 try expect(v[335] == 81);
7924 try expect(v[336] == 82);
7925 try expect(v[337] == 83);
7926 try expect(v[338] == 84);
7927 try expect(v[339] == 85);
7928 try expect(v[340] == 86);
7929 try expect(v[341] == 87);
7930 try expect(v[342] == 88);
7931 try expect(v[343] == 89);
7932 try expect(v[344] == 90);
7933 try expect(v[345] == 91);
7934 try expect(v[346] == 92);
7935 try expect(v[347] == 93);
7936 try expect(v[348] == 94);
7937 try expect(v[349] == 95);
7938 try expect(v[350] == 96);
7939 try expect(v[351] == 97);
7940 try expect(v[352] == 98);
7941 try expect(v[353] == 99);
7942 try expect(v[354] == 0);
7943 try expect(v[355] == 1);
7944 try expect(v[356] == 2);
7945 try expect(v[357] == 3);
7946 try expect(v[358] == 4);
7947 try expect(v[359] == 5);
7948 try expect(v[360] == 6);
7949 try expect(v[361] == 7);
7950 try expect(v[362] == 8);
7951 try expect(v[363] == 9);
7952 try expect(v[364] == 10);
7953 try expect(v[365] == 11);
7954 try expect(v[366] == 12);
7955 try expect(v[367] == 13);
7956 try expect(v[368] == 14);
7957 try expect(v[369] == 15);
7958 try expect(v[370] == 16);
7959 try expect(v[371] == 17);
7960 try expect(v[372] == 18);
7961 try expect(v[373] == 19);
7962 try expect(v[374] == 20);
7963 try expect(v[375] == 21);
7964 try expect(v[376] == 22);
7965 try expect(v[377] == 23);
7966 try expect(v[378] == 24);
7967 try expect(v[379] == 25);
7968 try expect(v[380] == 26);
7969 try expect(v[381] == 27);
7970 try expect(v[382] == 28);
7971 try expect(v[383] == 29);
7972 c_vector_384_u8(.{
7973 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
7974 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
7975 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
7976 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
7977 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
7978 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
7979 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
7980 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7981 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
7982 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
7983 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
7984 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
7985 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
7986 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7987 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7988 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7989 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7990 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7991 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7992 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7993 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
7994 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
7995 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
7996 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
7997 }, 384);
7998 c_test_vector_384_u8();
7999}
8000
8001export fn zig_ret_vector_512_u8() @Vector(512, u8) {
8002 return .{
8003 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
8004 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
8005 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
8006 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
8007 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
8008 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
8009 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
8010 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
8011 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
8012 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
8013 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
8014 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
8015 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
8016 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
8017 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
8018 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
8019 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
8020 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
8021 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
8022 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
8023 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
8024 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
8025 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
8026 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
8027 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
8028 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
8029 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
8030 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
8031 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
8032 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
8033 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
8034 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
8035 };
8036}
8037export fn zig_vector_512_u8(v: @Vector(512, u8), i: usize) void {
8038 expect(v[0] == 26) catch @panic("test failure");
8039 expect(v[1] == 27) catch @panic("test failure");
8040 expect(v[2] == 28) catch @panic("test failure");
8041 expect(v[3] == 29) catch @panic("test failure");
8042 expect(v[4] == 30) catch @panic("test failure");
8043 expect(v[5] == 31) catch @panic("test failure");
8044 expect(v[6] == 32) catch @panic("test failure");
8045 expect(v[7] == 33) catch @panic("test failure");
8046 expect(v[8] == 34) catch @panic("test failure");
8047 expect(v[9] == 35) catch @panic("test failure");
8048 expect(v[10] == 36) catch @panic("test failure");
8049 expect(v[11] == 37) catch @panic("test failure");
8050 expect(v[12] == 38) catch @panic("test failure");
8051 expect(v[13] == 39) catch @panic("test failure");
8052 expect(v[14] == 40) catch @panic("test failure");
8053 expect(v[15] == 41) catch @panic("test failure");
8054 expect(v[16] == 42) catch @panic("test failure");
8055 expect(v[17] == 43) catch @panic("test failure");
8056 expect(v[18] == 44) catch @panic("test failure");
8057 expect(v[19] == 45) catch @panic("test failure");
8058 expect(v[20] == 46) catch @panic("test failure");
8059 expect(v[21] == 47) catch @panic("test failure");
8060 expect(v[22] == 48) catch @panic("test failure");
8061 expect(v[23] == 49) catch @panic("test failure");
8062 expect(v[24] == 50) catch @panic("test failure");
8063 expect(v[25] == 51) catch @panic("test failure");
8064 expect(v[26] == 52) catch @panic("test failure");
8065 expect(v[27] == 53) catch @panic("test failure");
8066 expect(v[28] == 54) catch @panic("test failure");
8067 expect(v[29] == 55) catch @panic("test failure");
8068 expect(v[30] == 56) catch @panic("test failure");
8069 expect(v[31] == 57) catch @panic("test failure");
8070 expect(v[32] == 58) catch @panic("test failure");
8071 expect(v[33] == 59) catch @panic("test failure");
8072 expect(v[34] == 60) catch @panic("test failure");
8073 expect(v[35] == 61) catch @panic("test failure");
8074 expect(v[36] == 62) catch @panic("test failure");
8075 expect(v[37] == 63) catch @panic("test failure");
8076 expect(v[38] == 64) catch @panic("test failure");
8077 expect(v[39] == 65) catch @panic("test failure");
8078 expect(v[40] == 66) catch @panic("test failure");
8079 expect(v[41] == 67) catch @panic("test failure");
8080 expect(v[42] == 68) catch @panic("test failure");
8081 expect(v[43] == 69) catch @panic("test failure");
8082 expect(v[44] == 70) catch @panic("test failure");
8083 expect(v[45] == 71) catch @panic("test failure");
8084 expect(v[46] == 72) catch @panic("test failure");
8085 expect(v[47] == 73) catch @panic("test failure");
8086 expect(v[48] == 74) catch @panic("test failure");
8087 expect(v[49] == 75) catch @panic("test failure");
8088 expect(v[50] == 76) catch @panic("test failure");
8089 expect(v[51] == 77) catch @panic("test failure");
8090 expect(v[52] == 78) catch @panic("test failure");
8091 expect(v[53] == 79) catch @panic("test failure");
8092 expect(v[54] == 80) catch @panic("test failure");
8093 expect(v[55] == 81) catch @panic("test failure");
8094 expect(v[56] == 82) catch @panic("test failure");
8095 expect(v[57] == 83) catch @panic("test failure");
8096 expect(v[58] == 84) catch @panic("test failure");
8097 expect(v[59] == 85) catch @panic("test failure");
8098 expect(v[60] == 86) catch @panic("test failure");
8099 expect(v[61] == 87) catch @panic("test failure");
8100 expect(v[62] == 88) catch @panic("test failure");
8101 expect(v[63] == 89) catch @panic("test failure");
8102 expect(v[64] == 90) catch @panic("test failure");
8103 expect(v[65] == 91) catch @panic("test failure");
8104 expect(v[66] == 92) catch @panic("test failure");
8105 expect(v[67] == 93) catch @panic("test failure");
8106 expect(v[68] == 94) catch @panic("test failure");
8107 expect(v[69] == 95) catch @panic("test failure");
8108 expect(v[70] == 96) catch @panic("test failure");
8109 expect(v[71] == 97) catch @panic("test failure");
8110 expect(v[72] == 98) catch @panic("test failure");
8111 expect(v[73] == 99) catch @panic("test failure");
8112 expect(v[74] == 0) catch @panic("test failure");
8113 expect(v[75] == 1) catch @panic("test failure");
8114 expect(v[76] == 2) catch @panic("test failure");
8115 expect(v[77] == 3) catch @panic("test failure");
8116 expect(v[78] == 4) catch @panic("test failure");
8117 expect(v[79] == 5) catch @panic("test failure");
8118 expect(v[80] == 6) catch @panic("test failure");
8119 expect(v[81] == 7) catch @panic("test failure");
8120 expect(v[82] == 8) catch @panic("test failure");
8121 expect(v[83] == 9) catch @panic("test failure");
8122 expect(v[84] == 10) catch @panic("test failure");
8123 expect(v[85] == 11) catch @panic("test failure");
8124 expect(v[86] == 12) catch @panic("test failure");
8125 expect(v[87] == 13) catch @panic("test failure");
8126 expect(v[88] == 14) catch @panic("test failure");
8127 expect(v[89] == 15) catch @panic("test failure");
8128 expect(v[90] == 16) catch @panic("test failure");
8129 expect(v[91] == 17) catch @panic("test failure");
8130 expect(v[92] == 18) catch @panic("test failure");
8131 expect(v[93] == 19) catch @panic("test failure");
8132 expect(v[94] == 20) catch @panic("test failure");
8133 expect(v[95] == 21) catch @panic("test failure");
8134 expect(v[96] == 22) catch @panic("test failure");
8135 expect(v[97] == 23) catch @panic("test failure");
8136 expect(v[98] == 24) catch @panic("test failure");
8137 expect(v[99] == 25) catch @panic("test failure");
8138 expect(v[100] == 26) catch @panic("test failure");
8139 expect(v[101] == 27) catch @panic("test failure");
8140 expect(v[102] == 28) catch @panic("test failure");
8141 expect(v[103] == 29) catch @panic("test failure");
8142 expect(v[104] == 30) catch @panic("test failure");
8143 expect(v[105] == 31) catch @panic("test failure");
8144 expect(v[106] == 32) catch @panic("test failure");
8145 expect(v[107] == 33) catch @panic("test failure");
8146 expect(v[108] == 34) catch @panic("test failure");
8147 expect(v[109] == 35) catch @panic("test failure");
8148 expect(v[110] == 36) catch @panic("test failure");
8149 expect(v[111] == 37) catch @panic("test failure");
8150 expect(v[112] == 38) catch @panic("test failure");
8151 expect(v[113] == 39) catch @panic("test failure");
8152 expect(v[114] == 40) catch @panic("test failure");
8153 expect(v[115] == 41) catch @panic("test failure");
8154 expect(v[116] == 42) catch @panic("test failure");
8155 expect(v[117] == 43) catch @panic("test failure");
8156 expect(v[118] == 44) catch @panic("test failure");
8157 expect(v[119] == 45) catch @panic("test failure");
8158 expect(v[120] == 46) catch @panic("test failure");
8159 expect(v[121] == 47) catch @panic("test failure");
8160 expect(v[122] == 48) catch @panic("test failure");
8161 expect(v[123] == 49) catch @panic("test failure");
8162 expect(v[124] == 50) catch @panic("test failure");
8163 expect(v[125] == 51) catch @panic("test failure");
8164 expect(v[126] == 52) catch @panic("test failure");
8165 expect(v[127] == 53) catch @panic("test failure");
8166 expect(v[128] == 54) catch @panic("test failure");
8167 expect(v[129] == 55) catch @panic("test failure");
8168 expect(v[130] == 56) catch @panic("test failure");
8169 expect(v[131] == 57) catch @panic("test failure");
8170 expect(v[132] == 58) catch @panic("test failure");
8171 expect(v[133] == 59) catch @panic("test failure");
8172 expect(v[134] == 60) catch @panic("test failure");
8173 expect(v[135] == 61) catch @panic("test failure");
8174 expect(v[136] == 62) catch @panic("test failure");
8175 expect(v[137] == 63) catch @panic("test failure");
8176 expect(v[138] == 64) catch @panic("test failure");
8177 expect(v[139] == 65) catch @panic("test failure");
8178 expect(v[140] == 66) catch @panic("test failure");
8179 expect(v[141] == 67) catch @panic("test failure");
8180 expect(v[142] == 68) catch @panic("test failure");
8181 expect(v[143] == 69) catch @panic("test failure");
8182 expect(v[144] == 70) catch @panic("test failure");
8183 expect(v[145] == 71) catch @panic("test failure");
8184 expect(v[146] == 72) catch @panic("test failure");
8185 expect(v[147] == 73) catch @panic("test failure");
8186 expect(v[148] == 74) catch @panic("test failure");
8187 expect(v[149] == 75) catch @panic("test failure");
8188 expect(v[150] == 76) catch @panic("test failure");
8189 expect(v[151] == 77) catch @panic("test failure");
8190 expect(v[152] == 78) catch @panic("test failure");
8191 expect(v[153] == 79) catch @panic("test failure");
8192 expect(v[154] == 80) catch @panic("test failure");
8193 expect(v[155] == 81) catch @panic("test failure");
8194 expect(v[156] == 82) catch @panic("test failure");
8195 expect(v[157] == 83) catch @panic("test failure");
8196 expect(v[158] == 84) catch @panic("test failure");
8197 expect(v[159] == 85) catch @panic("test failure");
8198 expect(v[160] == 86) catch @panic("test failure");
8199 expect(v[161] == 87) catch @panic("test failure");
8200 expect(v[162] == 88) catch @panic("test failure");
8201 expect(v[163] == 89) catch @panic("test failure");
8202 expect(v[164] == 90) catch @panic("test failure");
8203 expect(v[165] == 91) catch @panic("test failure");
8204 expect(v[166] == 92) catch @panic("test failure");
8205 expect(v[167] == 93) catch @panic("test failure");
8206 expect(v[168] == 94) catch @panic("test failure");
8207 expect(v[169] == 95) catch @panic("test failure");
8208 expect(v[170] == 96) catch @panic("test failure");
8209 expect(v[171] == 97) catch @panic("test failure");
8210 expect(v[172] == 98) catch @panic("test failure");
8211 expect(v[173] == 99) catch @panic("test failure");
8212 expect(v[174] == 0) catch @panic("test failure");
8213 expect(v[175] == 1) catch @panic("test failure");
8214 expect(v[176] == 2) catch @panic("test failure");
8215 expect(v[177] == 3) catch @panic("test failure");
8216 expect(v[178] == 4) catch @panic("test failure");
8217 expect(v[179] == 5) catch @panic("test failure");
8218 expect(v[180] == 6) catch @panic("test failure");
8219 expect(v[181] == 7) catch @panic("test failure");
8220 expect(v[182] == 8) catch @panic("test failure");
8221 expect(v[183] == 9) catch @panic("test failure");
8222 expect(v[184] == 10) catch @panic("test failure");
8223 expect(v[185] == 11) catch @panic("test failure");
8224 expect(v[186] == 12) catch @panic("test failure");
8225 expect(v[187] == 13) catch @panic("test failure");
8226 expect(v[188] == 14) catch @panic("test failure");
8227 expect(v[189] == 15) catch @panic("test failure");
8228 expect(v[190] == 16) catch @panic("test failure");
8229 expect(v[191] == 17) catch @panic("test failure");
8230 expect(v[192] == 18) catch @panic("test failure");
8231 expect(v[193] == 19) catch @panic("test failure");
8232 expect(v[194] == 20) catch @panic("test failure");
8233 expect(v[195] == 21) catch @panic("test failure");
8234 expect(v[196] == 22) catch @panic("test failure");
8235 expect(v[197] == 23) catch @panic("test failure");
8236 expect(v[198] == 24) catch @panic("test failure");
8237 expect(v[199] == 25) catch @panic("test failure");
8238 expect(v[200] == 26) catch @panic("test failure");
8239 expect(v[201] == 27) catch @panic("test failure");
8240 expect(v[202] == 28) catch @panic("test failure");
8241 expect(v[203] == 29) catch @panic("test failure");
8242 expect(v[204] == 30) catch @panic("test failure");
8243 expect(v[205] == 31) catch @panic("test failure");
8244 expect(v[206] == 32) catch @panic("test failure");
8245 expect(v[207] == 33) catch @panic("test failure");
8246 expect(v[208] == 34) catch @panic("test failure");
8247 expect(v[209] == 35) catch @panic("test failure");
8248 expect(v[210] == 36) catch @panic("test failure");
8249 expect(v[211] == 37) catch @panic("test failure");
8250 expect(v[212] == 38) catch @panic("test failure");
8251 expect(v[213] == 39) catch @panic("test failure");
8252 expect(v[214] == 40) catch @panic("test failure");
8253 expect(v[215] == 41) catch @panic("test failure");
8254 expect(v[216] == 42) catch @panic("test failure");
8255 expect(v[217] == 43) catch @panic("test failure");
8256 expect(v[218] == 44) catch @panic("test failure");
8257 expect(v[219] == 45) catch @panic("test failure");
8258 expect(v[220] == 46) catch @panic("test failure");
8259 expect(v[221] == 47) catch @panic("test failure");
8260 expect(v[222] == 48) catch @panic("test failure");
8261 expect(v[223] == 49) catch @panic("test failure");
8262 expect(v[224] == 50) catch @panic("test failure");
8263 expect(v[225] == 51) catch @panic("test failure");
8264 expect(v[226] == 52) catch @panic("test failure");
8265 expect(v[227] == 53) catch @panic("test failure");
8266 expect(v[228] == 54) catch @panic("test failure");
8267 expect(v[229] == 55) catch @panic("test failure");
8268 expect(v[230] == 56) catch @panic("test failure");
8269 expect(v[231] == 57) catch @panic("test failure");
8270 expect(v[232] == 58) catch @panic("test failure");
8271 expect(v[233] == 59) catch @panic("test failure");
8272 expect(v[234] == 60) catch @panic("test failure");
8273 expect(v[235] == 61) catch @panic("test failure");
8274 expect(v[236] == 62) catch @panic("test failure");
8275 expect(v[237] == 63) catch @panic("test failure");
8276 expect(v[238] == 64) catch @panic("test failure");
8277 expect(v[239] == 65) catch @panic("test failure");
8278 expect(v[240] == 66) catch @panic("test failure");
8279 expect(v[241] == 67) catch @panic("test failure");
8280 expect(v[242] == 68) catch @panic("test failure");
8281 expect(v[243] == 69) catch @panic("test failure");
8282 expect(v[244] == 70) catch @panic("test failure");
8283 expect(v[245] == 71) catch @panic("test failure");
8284 expect(v[246] == 72) catch @panic("test failure");
8285 expect(v[247] == 73) catch @panic("test failure");
8286 expect(v[248] == 74) catch @panic("test failure");
8287 expect(v[249] == 75) catch @panic("test failure");
8288 expect(v[250] == 76) catch @panic("test failure");
8289 expect(v[251] == 77) catch @panic("test failure");
8290 expect(v[252] == 78) catch @panic("test failure");
8291 expect(v[253] == 79) catch @panic("test failure");
8292 expect(v[254] == 80) catch @panic("test failure");
8293 expect(v[255] == 81) catch @panic("test failure");
8294 expect(v[256] == 82) catch @panic("test failure");
8295 expect(v[257] == 83) catch @panic("test failure");
8296 expect(v[258] == 84) catch @panic("test failure");
8297 expect(v[259] == 85) catch @panic("test failure");
8298 expect(v[260] == 86) catch @panic("test failure");
8299 expect(v[261] == 87) catch @panic("test failure");
8300 expect(v[262] == 88) catch @panic("test failure");
8301 expect(v[263] == 89) catch @panic("test failure");
8302 expect(v[264] == 90) catch @panic("test failure");
8303 expect(v[265] == 91) catch @panic("test failure");
8304 expect(v[266] == 92) catch @panic("test failure");
8305 expect(v[267] == 93) catch @panic("test failure");
8306 expect(v[268] == 94) catch @panic("test failure");
8307 expect(v[269] == 95) catch @panic("test failure");
8308 expect(v[270] == 96) catch @panic("test failure");
8309 expect(v[271] == 97) catch @panic("test failure");
8310 expect(v[272] == 98) catch @panic("test failure");
8311 expect(v[273] == 99) catch @panic("test failure");
8312 expect(v[274] == 0) catch @panic("test failure");
8313 expect(v[275] == 1) catch @panic("test failure");
8314 expect(v[276] == 2) catch @panic("test failure");
8315 expect(v[277] == 3) catch @panic("test failure");
8316 expect(v[278] == 4) catch @panic("test failure");
8317 expect(v[279] == 5) catch @panic("test failure");
8318 expect(v[280] == 6) catch @panic("test failure");
8319 expect(v[281] == 7) catch @panic("test failure");
8320 expect(v[282] == 8) catch @panic("test failure");
8321 expect(v[283] == 9) catch @panic("test failure");
8322 expect(v[284] == 10) catch @panic("test failure");
8323 expect(v[285] == 11) catch @panic("test failure");
8324 expect(v[286] == 12) catch @panic("test failure");
8325 expect(v[287] == 13) catch @panic("test failure");
8326 expect(v[288] == 14) catch @panic("test failure");
8327 expect(v[289] == 15) catch @panic("test failure");
8328 expect(v[290] == 16) catch @panic("test failure");
8329 expect(v[291] == 17) catch @panic("test failure");
8330 expect(v[292] == 18) catch @panic("test failure");
8331 expect(v[293] == 19) catch @panic("test failure");
8332 expect(v[294] == 20) catch @panic("test failure");
8333 expect(v[295] == 21) catch @panic("test failure");
8334 expect(v[296] == 22) catch @panic("test failure");
8335 expect(v[297] == 23) catch @panic("test failure");
8336 expect(v[298] == 24) catch @panic("test failure");
8337 expect(v[299] == 25) catch @panic("test failure");
8338 expect(v[300] == 26) catch @panic("test failure");
8339 expect(v[301] == 27) catch @panic("test failure");
8340 expect(v[302] == 28) catch @panic("test failure");
8341 expect(v[303] == 29) catch @panic("test failure");
8342 expect(v[304] == 30) catch @panic("test failure");
8343 expect(v[305] == 31) catch @panic("test failure");
8344 expect(v[306] == 32) catch @panic("test failure");
8345 expect(v[307] == 33) catch @panic("test failure");
8346 expect(v[308] == 34) catch @panic("test failure");
8347 expect(v[309] == 35) catch @panic("test failure");
8348 expect(v[310] == 36) catch @panic("test failure");
8349 expect(v[311] == 37) catch @panic("test failure");
8350 expect(v[312] == 38) catch @panic("test failure");
8351 expect(v[313] == 39) catch @panic("test failure");
8352 expect(v[314] == 40) catch @panic("test failure");
8353 expect(v[315] == 41) catch @panic("test failure");
8354 expect(v[316] == 42) catch @panic("test failure");
8355 expect(v[317] == 43) catch @panic("test failure");
8356 expect(v[318] == 44) catch @panic("test failure");
8357 expect(v[319] == 45) catch @panic("test failure");
8358 expect(v[320] == 46) catch @panic("test failure");
8359 expect(v[321] == 47) catch @panic("test failure");
8360 expect(v[322] == 48) catch @panic("test failure");
8361 expect(v[323] == 49) catch @panic("test failure");
8362 expect(v[324] == 50) catch @panic("test failure");
8363 expect(v[325] == 51) catch @panic("test failure");
8364 expect(v[326] == 52) catch @panic("test failure");
8365 expect(v[327] == 53) catch @panic("test failure");
8366 expect(v[328] == 54) catch @panic("test failure");
8367 expect(v[329] == 55) catch @panic("test failure");
8368 expect(v[330] == 56) catch @panic("test failure");
8369 expect(v[331] == 57) catch @panic("test failure");
8370 expect(v[332] == 58) catch @panic("test failure");
8371 expect(v[333] == 59) catch @panic("test failure");
8372 expect(v[334] == 60) catch @panic("test failure");
8373 expect(v[335] == 61) catch @panic("test failure");
8374 expect(v[336] == 62) catch @panic("test failure");
8375 expect(v[337] == 63) catch @panic("test failure");
8376 expect(v[338] == 64) catch @panic("test failure");
8377 expect(v[339] == 65) catch @panic("test failure");
8378 expect(v[340] == 66) catch @panic("test failure");
8379 expect(v[341] == 67) catch @panic("test failure");
8380 expect(v[342] == 68) catch @panic("test failure");
8381 expect(v[343] == 69) catch @panic("test failure");
8382 expect(v[344] == 70) catch @panic("test failure");
8383 expect(v[345] == 71) catch @panic("test failure");
8384 expect(v[346] == 72) catch @panic("test failure");
8385 expect(v[347] == 73) catch @panic("test failure");
8386 expect(v[348] == 74) catch @panic("test failure");
8387 expect(v[349] == 75) catch @panic("test failure");
8388 expect(v[350] == 76) catch @panic("test failure");
8389 expect(v[351] == 77) catch @panic("test failure");
8390 expect(v[352] == 78) catch @panic("test failure");
8391 expect(v[353] == 79) catch @panic("test failure");
8392 expect(v[354] == 80) catch @panic("test failure");
8393 expect(v[355] == 81) catch @panic("test failure");
8394 expect(v[356] == 82) catch @panic("test failure");
8395 expect(v[357] == 83) catch @panic("test failure");
8396 expect(v[358] == 84) catch @panic("test failure");
8397 expect(v[359] == 85) catch @panic("test failure");
8398 expect(v[360] == 86) catch @panic("test failure");
8399 expect(v[361] == 87) catch @panic("test failure");
8400 expect(v[362] == 88) catch @panic("test failure");
8401 expect(v[363] == 89) catch @panic("test failure");
8402 expect(v[364] == 90) catch @panic("test failure");
8403 expect(v[365] == 91) catch @panic("test failure");
8404 expect(v[366] == 92) catch @panic("test failure");
8405 expect(v[367] == 93) catch @panic("test failure");
8406 expect(v[368] == 94) catch @panic("test failure");
8407 expect(v[369] == 95) catch @panic("test failure");
8408 expect(v[370] == 96) catch @panic("test failure");
8409 expect(v[371] == 97) catch @panic("test failure");
8410 expect(v[372] == 98) catch @panic("test failure");
8411 expect(v[373] == 99) catch @panic("test failure");
8412 expect(v[374] == 0) catch @panic("test failure");
8413 expect(v[375] == 1) catch @panic("test failure");
8414 expect(v[376] == 2) catch @panic("test failure");
8415 expect(v[377] == 3) catch @panic("test failure");
8416 expect(v[378] == 4) catch @panic("test failure");
8417 expect(v[379] == 5) catch @panic("test failure");
8418 expect(v[380] == 6) catch @panic("test failure");
8419 expect(v[381] == 7) catch @panic("test failure");
8420 expect(v[382] == 8) catch @panic("test failure");
8421 expect(v[383] == 9) catch @panic("test failure");
8422 expect(v[384] == 10) catch @panic("test failure");
8423 expect(v[385] == 11) catch @panic("test failure");
8424 expect(v[386] == 12) catch @panic("test failure");
8425 expect(v[387] == 13) catch @panic("test failure");
8426 expect(v[388] == 14) catch @panic("test failure");
8427 expect(v[389] == 15) catch @panic("test failure");
8428 expect(v[390] == 16) catch @panic("test failure");
8429 expect(v[391] == 17) catch @panic("test failure");
8430 expect(v[392] == 18) catch @panic("test failure");
8431 expect(v[393] == 19) catch @panic("test failure");
8432 expect(v[394] == 20) catch @panic("test failure");
8433 expect(v[395] == 21) catch @panic("test failure");
8434 expect(v[396] == 22) catch @panic("test failure");
8435 expect(v[397] == 23) catch @panic("test failure");
8436 expect(v[398] == 24) catch @panic("test failure");
8437 expect(v[399] == 25) catch @panic("test failure");
8438 expect(v[400] == 26) catch @panic("test failure");
8439 expect(v[401] == 27) catch @panic("test failure");
8440 expect(v[402] == 28) catch @panic("test failure");
8441 expect(v[403] == 29) catch @panic("test failure");
8442 expect(v[404] == 30) catch @panic("test failure");
8443 expect(v[405] == 31) catch @panic("test failure");
8444 expect(v[406] == 32) catch @panic("test failure");
8445 expect(v[407] == 33) catch @panic("test failure");
8446 expect(v[408] == 34) catch @panic("test failure");
8447 expect(v[409] == 35) catch @panic("test failure");
8448 expect(v[410] == 36) catch @panic("test failure");
8449 expect(v[411] == 37) catch @panic("test failure");
8450 expect(v[412] == 38) catch @panic("test failure");
8451 expect(v[413] == 39) catch @panic("test failure");
8452 expect(v[414] == 40) catch @panic("test failure");
8453 expect(v[415] == 41) catch @panic("test failure");
8454 expect(v[416] == 42) catch @panic("test failure");
8455 expect(v[417] == 43) catch @panic("test failure");
8456 expect(v[418] == 44) catch @panic("test failure");
8457 expect(v[419] == 45) catch @panic("test failure");
8458 expect(v[420] == 46) catch @panic("test failure");
8459 expect(v[421] == 47) catch @panic("test failure");
8460 expect(v[422] == 48) catch @panic("test failure");
8461 expect(v[423] == 49) catch @panic("test failure");
8462 expect(v[424] == 50) catch @panic("test failure");
8463 expect(v[425] == 51) catch @panic("test failure");
8464 expect(v[426] == 52) catch @panic("test failure");
8465 expect(v[427] == 53) catch @panic("test failure");
8466 expect(v[428] == 54) catch @panic("test failure");
8467 expect(v[429] == 55) catch @panic("test failure");
8468 expect(v[430] == 56) catch @panic("test failure");
8469 expect(v[431] == 57) catch @panic("test failure");
8470 expect(v[432] == 58) catch @panic("test failure");
8471 expect(v[433] == 59) catch @panic("test failure");
8472 expect(v[434] == 60) catch @panic("test failure");
8473 expect(v[435] == 61) catch @panic("test failure");
8474 expect(v[436] == 62) catch @panic("test failure");
8475 expect(v[437] == 63) catch @panic("test failure");
8476 expect(v[438] == 64) catch @panic("test failure");
8477 expect(v[439] == 65) catch @panic("test failure");
8478 expect(v[440] == 66) catch @panic("test failure");
8479 expect(v[441] == 67) catch @panic("test failure");
8480 expect(v[442] == 68) catch @panic("test failure");
8481 expect(v[443] == 69) catch @panic("test failure");
8482 expect(v[444] == 70) catch @panic("test failure");
8483 expect(v[445] == 71) catch @panic("test failure");
8484 expect(v[446] == 72) catch @panic("test failure");
8485 expect(v[447] == 73) catch @panic("test failure");
8486 expect(v[448] == 74) catch @panic("test failure");
8487 expect(v[449] == 75) catch @panic("test failure");
8488 expect(v[450] == 76) catch @panic("test failure");
8489 expect(v[451] == 77) catch @panic("test failure");
8490 expect(v[452] == 78) catch @panic("test failure");
8491 expect(v[453] == 79) catch @panic("test failure");
8492 expect(v[454] == 80) catch @panic("test failure");
8493 expect(v[455] == 81) catch @panic("test failure");
8494 expect(v[456] == 82) catch @panic("test failure");
8495 expect(v[457] == 83) catch @panic("test failure");
8496 expect(v[458] == 84) catch @panic("test failure");
8497 expect(v[459] == 85) catch @panic("test failure");
8498 expect(v[460] == 86) catch @panic("test failure");
8499 expect(v[461] == 87) catch @panic("test failure");
8500 expect(v[462] == 88) catch @panic("test failure");
8501 expect(v[463] == 89) catch @panic("test failure");
8502 expect(v[464] == 90) catch @panic("test failure");
8503 expect(v[465] == 91) catch @panic("test failure");
8504 expect(v[466] == 92) catch @panic("test failure");
8505 expect(v[467] == 93) catch @panic("test failure");
8506 expect(v[468] == 94) catch @panic("test failure");
8507 expect(v[469] == 95) catch @panic("test failure");
8508 expect(v[470] == 96) catch @panic("test failure");
8509 expect(v[471] == 97) catch @panic("test failure");
8510 expect(v[472] == 98) catch @panic("test failure");
8511 expect(v[473] == 99) catch @panic("test failure");
8512 expect(v[474] == 0) catch @panic("test failure");
8513 expect(v[475] == 1) catch @panic("test failure");
8514 expect(v[476] == 2) catch @panic("test failure");
8515 expect(v[477] == 3) catch @panic("test failure");
8516 expect(v[478] == 4) catch @panic("test failure");
8517 expect(v[479] == 5) catch @panic("test failure");
8518 expect(v[480] == 6) catch @panic("test failure");
8519 expect(v[481] == 7) catch @panic("test failure");
8520 expect(v[482] == 8) catch @panic("test failure");
8521 expect(v[483] == 9) catch @panic("test failure");
8522 expect(v[484] == 10) catch @panic("test failure");
8523 expect(v[485] == 11) catch @panic("test failure");
8524 expect(v[486] == 12) catch @panic("test failure");
8525 expect(v[487] == 13) catch @panic("test failure");
8526 expect(v[488] == 14) catch @panic("test failure");
8527 expect(v[489] == 15) catch @panic("test failure");
8528 expect(v[490] == 16) catch @panic("test failure");
8529 expect(v[491] == 17) catch @panic("test failure");
8530 expect(v[492] == 18) catch @panic("test failure");
8531 expect(v[493] == 19) catch @panic("test failure");
8532 expect(v[494] == 20) catch @panic("test failure");
8533 expect(v[495] == 21) catch @panic("test failure");
8534 expect(v[496] == 22) catch @panic("test failure");
8535 expect(v[497] == 23) catch @panic("test failure");
8536 expect(v[498] == 24) catch @panic("test failure");
8537 expect(v[499] == 25) catch @panic("test failure");
8538 expect(v[500] == 26) catch @panic("test failure");
8539 expect(v[501] == 27) catch @panic("test failure");
8540 expect(v[502] == 28) catch @panic("test failure");
8541 expect(v[503] == 29) catch @panic("test failure");
8542 expect(v[504] == 30) catch @panic("test failure");
8543 expect(v[505] == 31) catch @panic("test failure");
8544 expect(v[506] == 32) catch @panic("test failure");
8545 expect(v[507] == 33) catch @panic("test failure");
8546 expect(v[508] == 34) catch @panic("test failure");
8547 expect(v[509] == 35) catch @panic("test failure");
8548 expect(v[510] == 36) catch @panic("test failure");
8549 expect(v[511] == 37) catch @panic("test failure");
8550 expect(i == 512) catch @panic("test failure");
8551}
8552
8553extern fn c_ret_vector_512_u8() @Vector(512, u8);
8554extern fn c_vector_512_u8(@Vector(512, u8), usize) void;
8555extern fn c_test_vector_512_u8() void;
8556
8557test "@Vector(512, u8)" {
8558 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
8559 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
8560 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
8561 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
8562
8563 const v = c_ret_vector_512_u8();
8564 try expect(v[0] == 38);
8565 try expect(v[1] == 39);
8566 try expect(v[2] == 40);
8567 try expect(v[3] == 41);
8568 try expect(v[4] == 42);
8569 try expect(v[5] == 43);
8570 try expect(v[6] == 44);
8571 try expect(v[7] == 45);
8572 try expect(v[8] == 46);
8573 try expect(v[9] == 47);
8574 try expect(v[10] == 48);
8575 try expect(v[11] == 49);
8576 try expect(v[12] == 50);
8577 try expect(v[13] == 51);
8578 try expect(v[14] == 52);
8579 try expect(v[15] == 53);
8580 try expect(v[16] == 54);
8581 try expect(v[17] == 55);
8582 try expect(v[18] == 56);
8583 try expect(v[19] == 57);
8584 try expect(v[20] == 58);
8585 try expect(v[21] == 59);
8586 try expect(v[22] == 60);
8587 try expect(v[23] == 61);
8588 try expect(v[24] == 62);
8589 try expect(v[25] == 63);
8590 try expect(v[26] == 64);
8591 try expect(v[27] == 65);
8592 try expect(v[28] == 66);
8593 try expect(v[29] == 67);
8594 try expect(v[30] == 68);
8595 try expect(v[31] == 69);
8596 try expect(v[32] == 70);
8597 try expect(v[33] == 71);
8598 try expect(v[34] == 72);
8599 try expect(v[35] == 73);
8600 try expect(v[36] == 74);
8601 try expect(v[37] == 75);
8602 try expect(v[38] == 76);
8603 try expect(v[39] == 77);
8604 try expect(v[40] == 78);
8605 try expect(v[41] == 79);
8606 try expect(v[42] == 80);
8607 try expect(v[43] == 81);
8608 try expect(v[44] == 82);
8609 try expect(v[45] == 83);
8610 try expect(v[46] == 84);
8611 try expect(v[47] == 85);
8612 try expect(v[48] == 86);
8613 try expect(v[49] == 87);
8614 try expect(v[50] == 88);
8615 try expect(v[51] == 89);
8616 try expect(v[52] == 90);
8617 try expect(v[53] == 91);
8618 try expect(v[54] == 92);
8619 try expect(v[55] == 93);
8620 try expect(v[56] == 94);
8621 try expect(v[57] == 95);
8622 try expect(v[58] == 96);
8623 try expect(v[59] == 97);
8624 try expect(v[60] == 98);
8625 try expect(v[61] == 99);
8626 try expect(v[62] == 0);
8627 try expect(v[63] == 1);
8628 try expect(v[64] == 2);
8629 try expect(v[65] == 3);
8630 try expect(v[66] == 4);
8631 try expect(v[67] == 5);
8632 try expect(v[68] == 6);
8633 try expect(v[69] == 7);
8634 try expect(v[70] == 8);
8635 try expect(v[71] == 9);
8636 try expect(v[72] == 10);
8637 try expect(v[73] == 11);
8638 try expect(v[74] == 12);
8639 try expect(v[75] == 13);
8640 try expect(v[76] == 14);
8641 try expect(v[77] == 15);
8642 try expect(v[78] == 16);
8643 try expect(v[79] == 17);
8644 try expect(v[80] == 18);
8645 try expect(v[81] == 19);
8646 try expect(v[82] == 20);
8647 try expect(v[83] == 21);
8648 try expect(v[84] == 22);
8649 try expect(v[85] == 23);
8650 try expect(v[86] == 24);
8651 try expect(v[87] == 25);
8652 try expect(v[88] == 26);
8653 try expect(v[89] == 27);
8654 try expect(v[90] == 28);
8655 try expect(v[91] == 29);
8656 try expect(v[92] == 30);
8657 try expect(v[93] == 31);
8658 try expect(v[94] == 32);
8659 try expect(v[95] == 33);
8660 try expect(v[96] == 34);
8661 try expect(v[97] == 35);
8662 try expect(v[98] == 36);
8663 try expect(v[99] == 37);
8664 try expect(v[100] == 38);
8665 try expect(v[101] == 39);
8666 try expect(v[102] == 40);
8667 try expect(v[103] == 41);
8668 try expect(v[104] == 42);
8669 try expect(v[105] == 43);
8670 try expect(v[106] == 44);
8671 try expect(v[107] == 45);
8672 try expect(v[108] == 46);
8673 try expect(v[109] == 47);
8674 try expect(v[110] == 48);
8675 try expect(v[111] == 49);
8676 try expect(v[112] == 50);
8677 try expect(v[113] == 51);
8678 try expect(v[114] == 52);
8679 try expect(v[115] == 53);
8680 try expect(v[116] == 54);
8681 try expect(v[117] == 55);
8682 try expect(v[118] == 56);
8683 try expect(v[119] == 57);
8684 try expect(v[120] == 58);
8685 try expect(v[121] == 59);
8686 try expect(v[122] == 60);
8687 try expect(v[123] == 61);
8688 try expect(v[124] == 62);
8689 try expect(v[125] == 63);
8690 try expect(v[126] == 64);
8691 try expect(v[127] == 65);
8692 try expect(v[128] == 66);
8693 try expect(v[129] == 67);
8694 try expect(v[130] == 68);
8695 try expect(v[131] == 69);
8696 try expect(v[132] == 70);
8697 try expect(v[133] == 71);
8698 try expect(v[134] == 72);
8699 try expect(v[135] == 73);
8700 try expect(v[136] == 74);
8701 try expect(v[137] == 75);
8702 try expect(v[138] == 76);
8703 try expect(v[139] == 77);
8704 try expect(v[140] == 78);
8705 try expect(v[141] == 79);
8706 try expect(v[142] == 80);
8707 try expect(v[143] == 81);
8708 try expect(v[144] == 82);
8709 try expect(v[145] == 83);
8710 try expect(v[146] == 84);
8711 try expect(v[147] == 85);
8712 try expect(v[148] == 86);
8713 try expect(v[149] == 87);
8714 try expect(v[150] == 88);
8715 try expect(v[151] == 89);
8716 try expect(v[152] == 90);
8717 try expect(v[153] == 91);
8718 try expect(v[154] == 92);
8719 try expect(v[155] == 93);
8720 try expect(v[156] == 94);
8721 try expect(v[157] == 95);
8722 try expect(v[158] == 96);
8723 try expect(v[159] == 97);
8724 try expect(v[160] == 98);
8725 try expect(v[161] == 99);
8726 try expect(v[162] == 0);
8727 try expect(v[163] == 1);
8728 try expect(v[164] == 2);
8729 try expect(v[165] == 3);
8730 try expect(v[166] == 4);
8731 try expect(v[167] == 5);
8732 try expect(v[168] == 6);
8733 try expect(v[169] == 7);
8734 try expect(v[170] == 8);
8735 try expect(v[171] == 9);
8736 try expect(v[172] == 10);
8737 try expect(v[173] == 11);
8738 try expect(v[174] == 12);
8739 try expect(v[175] == 13);
8740 try expect(v[176] == 14);
8741 try expect(v[177] == 15);
8742 try expect(v[178] == 16);
8743 try expect(v[179] == 17);
8744 try expect(v[180] == 18);
8745 try expect(v[181] == 19);
8746 try expect(v[182] == 20);
8747 try expect(v[183] == 21);
8748 try expect(v[184] == 22);
8749 try expect(v[185] == 23);
8750 try expect(v[186] == 24);
8751 try expect(v[187] == 25);
8752 try expect(v[188] == 26);
8753 try expect(v[189] == 27);
8754 try expect(v[190] == 28);
8755 try expect(v[191] == 29);
8756 try expect(v[192] == 30);
8757 try expect(v[193] == 31);
8758 try expect(v[194] == 32);
8759 try expect(v[195] == 33);
8760 try expect(v[196] == 34);
8761 try expect(v[197] == 35);
8762 try expect(v[198] == 36);
8763 try expect(v[199] == 37);
8764 try expect(v[200] == 38);
8765 try expect(v[201] == 39);
8766 try expect(v[202] == 40);
8767 try expect(v[203] == 41);
8768 try expect(v[204] == 42);
8769 try expect(v[205] == 43);
8770 try expect(v[206] == 44);
8771 try expect(v[207] == 45);
8772 try expect(v[208] == 46);
8773 try expect(v[209] == 47);
8774 try expect(v[210] == 48);
8775 try expect(v[211] == 49);
8776 try expect(v[212] == 50);
8777 try expect(v[213] == 51);
8778 try expect(v[214] == 52);
8779 try expect(v[215] == 53);
8780 try expect(v[216] == 54);
8781 try expect(v[217] == 55);
8782 try expect(v[218] == 56);
8783 try expect(v[219] == 57);
8784 try expect(v[220] == 58);
8785 try expect(v[221] == 59);
8786 try expect(v[222] == 60);
8787 try expect(v[223] == 61);
8788 try expect(v[224] == 62);
8789 try expect(v[225] == 63);
8790 try expect(v[226] == 64);
8791 try expect(v[227] == 65);
8792 try expect(v[228] == 66);
8793 try expect(v[229] == 67);
8794 try expect(v[230] == 68);
8795 try expect(v[231] == 69);
8796 try expect(v[232] == 70);
8797 try expect(v[233] == 71);
8798 try expect(v[234] == 72);
8799 try expect(v[235] == 73);
8800 try expect(v[236] == 74);
8801 try expect(v[237] == 75);
8802 try expect(v[238] == 76);
8803 try expect(v[239] == 77);
8804 try expect(v[240] == 78);
8805 try expect(v[241] == 79);
8806 try expect(v[242] == 80);
8807 try expect(v[243] == 81);
8808 try expect(v[244] == 82);
8809 try expect(v[245] == 83);
8810 try expect(v[246] == 84);
8811 try expect(v[247] == 85);
8812 try expect(v[248] == 86);
8813 try expect(v[249] == 87);
8814 try expect(v[250] == 88);
8815 try expect(v[251] == 89);
8816 try expect(v[252] == 90);
8817 try expect(v[253] == 91);
8818 try expect(v[254] == 92);
8819 try expect(v[255] == 93);
8820 try expect(v[256] == 94);
8821 try expect(v[257] == 95);
8822 try expect(v[258] == 96);
8823 try expect(v[259] == 97);
8824 try expect(v[260] == 98);
8825 try expect(v[261] == 99);
8826 try expect(v[262] == 0);
8827 try expect(v[263] == 1);
8828 try expect(v[264] == 2);
8829 try expect(v[265] == 3);
8830 try expect(v[266] == 4);
8831 try expect(v[267] == 5);
8832 try expect(v[268] == 6);
8833 try expect(v[269] == 7);
8834 try expect(v[270] == 8);
8835 try expect(v[271] == 9);
8836 try expect(v[272] == 10);
8837 try expect(v[273] == 11);
8838 try expect(v[274] == 12);
8839 try expect(v[275] == 13);
8840 try expect(v[276] == 14);
8841 try expect(v[277] == 15);
8842 try expect(v[278] == 16);
8843 try expect(v[279] == 17);
8844 try expect(v[280] == 18);
8845 try expect(v[281] == 19);
8846 try expect(v[282] == 20);
8847 try expect(v[283] == 21);
8848 try expect(v[284] == 22);
8849 try expect(v[285] == 23);
8850 try expect(v[286] == 24);
8851 try expect(v[287] == 25);
8852 try expect(v[288] == 26);
8853 try expect(v[289] == 27);
8854 try expect(v[290] == 28);
8855 try expect(v[291] == 29);
8856 try expect(v[292] == 30);
8857 try expect(v[293] == 31);
8858 try expect(v[294] == 32);
8859 try expect(v[295] == 33);
8860 try expect(v[296] == 34);
8861 try expect(v[297] == 35);
8862 try expect(v[298] == 36);
8863 try expect(v[299] == 37);
8864 try expect(v[300] == 38);
8865 try expect(v[301] == 39);
8866 try expect(v[302] == 40);
8867 try expect(v[303] == 41);
8868 try expect(v[304] == 42);
8869 try expect(v[305] == 43);
8870 try expect(v[306] == 44);
8871 try expect(v[307] == 45);
8872 try expect(v[308] == 46);
8873 try expect(v[309] == 47);
8874 try expect(v[310] == 48);
8875 try expect(v[311] == 49);
8876 try expect(v[312] == 50);
8877 try expect(v[313] == 51);
8878 try expect(v[314] == 52);
8879 try expect(v[315] == 53);
8880 try expect(v[316] == 54);
8881 try expect(v[317] == 55);
8882 try expect(v[318] == 56);
8883 try expect(v[319] == 57);
8884 try expect(v[320] == 58);
8885 try expect(v[321] == 59);
8886 try expect(v[322] == 60);
8887 try expect(v[323] == 61);
8888 try expect(v[324] == 62);
8889 try expect(v[325] == 63);
8890 try expect(v[326] == 64);
8891 try expect(v[327] == 65);
8892 try expect(v[328] == 66);
8893 try expect(v[329] == 67);
8894 try expect(v[330] == 68);
8895 try expect(v[331] == 69);
8896 try expect(v[332] == 70);
8897 try expect(v[333] == 71);
8898 try expect(v[334] == 72);
8899 try expect(v[335] == 73);
8900 try expect(v[336] == 74);
8901 try expect(v[337] == 75);
8902 try expect(v[338] == 76);
8903 try expect(v[339] == 77);
8904 try expect(v[340] == 78);
8905 try expect(v[341] == 79);
8906 try expect(v[342] == 80);
8907 try expect(v[343] == 81);
8908 try expect(v[344] == 82);
8909 try expect(v[345] == 83);
8910 try expect(v[346] == 84);
8911 try expect(v[347] == 85);
8912 try expect(v[348] == 86);
8913 try expect(v[349] == 87);
8914 try expect(v[350] == 88);
8915 try expect(v[351] == 89);
8916 try expect(v[352] == 90);
8917 try expect(v[353] == 91);
8918 try expect(v[354] == 92);
8919 try expect(v[355] == 93);
8920 try expect(v[356] == 94);
8921 try expect(v[357] == 95);
8922 try expect(v[358] == 96);
8923 try expect(v[359] == 97);
8924 try expect(v[360] == 98);
8925 try expect(v[361] == 99);
8926 try expect(v[362] == 0);
8927 try expect(v[363] == 1);
8928 try expect(v[364] == 2);
8929 try expect(v[365] == 3);
8930 try expect(v[366] == 4);
8931 try expect(v[367] == 5);
8932 try expect(v[368] == 6);
8933 try expect(v[369] == 7);
8934 try expect(v[370] == 8);
8935 try expect(v[371] == 9);
8936 try expect(v[372] == 10);
8937 try expect(v[373] == 11);
8938 try expect(v[374] == 12);
8939 try expect(v[375] == 13);
8940 try expect(v[376] == 14);
8941 try expect(v[377] == 15);
8942 try expect(v[378] == 16);
8943 try expect(v[379] == 17);
8944 try expect(v[380] == 18);
8945 try expect(v[381] == 19);
8946 try expect(v[382] == 20);
8947 try expect(v[383] == 21);
8948 try expect(v[384] == 22);
8949 try expect(v[385] == 23);
8950 try expect(v[386] == 24);
8951 try expect(v[387] == 25);
8952 try expect(v[388] == 26);
8953 try expect(v[389] == 27);
8954 try expect(v[390] == 28);
8955 try expect(v[391] == 29);
8956 try expect(v[392] == 30);
8957 try expect(v[393] == 31);
8958 try expect(v[394] == 32);
8959 try expect(v[395] == 33);
8960 try expect(v[396] == 34);
8961 try expect(v[397] == 35);
8962 try expect(v[398] == 36);
8963 try expect(v[399] == 37);
8964 try expect(v[400] == 38);
8965 try expect(v[401] == 39);
8966 try expect(v[402] == 40);
8967 try expect(v[403] == 41);
8968 try expect(v[404] == 42);
8969 try expect(v[405] == 43);
8970 try expect(v[406] == 44);
8971 try expect(v[407] == 45);
8972 try expect(v[408] == 46);
8973 try expect(v[409] == 47);
8974 try expect(v[410] == 48);
8975 try expect(v[411] == 49);
8976 try expect(v[412] == 50);
8977 try expect(v[413] == 51);
8978 try expect(v[414] == 52);
8979 try expect(v[415] == 53);
8980 try expect(v[416] == 54);
8981 try expect(v[417] == 55);
8982 try expect(v[418] == 56);
8983 try expect(v[419] == 57);
8984 try expect(v[420] == 58);
8985 try expect(v[421] == 59);
8986 try expect(v[422] == 60);
8987 try expect(v[423] == 61);
8988 try expect(v[424] == 62);
8989 try expect(v[425] == 63);
8990 try expect(v[426] == 64);
8991 try expect(v[427] == 65);
8992 try expect(v[428] == 66);
8993 try expect(v[429] == 67);
8994 try expect(v[430] == 68);
8995 try expect(v[431] == 69);
8996 try expect(v[432] == 70);
8997 try expect(v[433] == 71);
8998 try expect(v[434] == 72);
8999 try expect(v[435] == 73);
9000 try expect(v[436] == 74);
9001 try expect(v[437] == 75);
9002 try expect(v[438] == 76);
9003 try expect(v[439] == 77);
9004 try expect(v[440] == 78);
9005 try expect(v[441] == 79);
9006 try expect(v[442] == 80);
9007 try expect(v[443] == 81);
9008 try expect(v[444] == 82);
9009 try expect(v[445] == 83);
9010 try expect(v[446] == 84);
9011 try expect(v[447] == 85);
9012 try expect(v[448] == 86);
9013 try expect(v[449] == 87);
9014 try expect(v[450] == 88);
9015 try expect(v[451] == 89);
9016 try expect(v[452] == 90);
9017 try expect(v[453] == 91);
9018 try expect(v[454] == 92);
9019 try expect(v[455] == 93);
9020 try expect(v[456] == 94);
9021 try expect(v[457] == 95);
9022 try expect(v[458] == 96);
9023 try expect(v[459] == 97);
9024 try expect(v[460] == 98);
9025 try expect(v[461] == 99);
9026 try expect(v[462] == 0);
9027 try expect(v[463] == 1);
9028 try expect(v[464] == 2);
9029 try expect(v[465] == 3);
9030 try expect(v[466] == 4);
9031 try expect(v[467] == 5);
9032 try expect(v[468] == 6);
9033 try expect(v[469] == 7);
9034 try expect(v[470] == 8);
9035 try expect(v[471] == 9);
9036 try expect(v[472] == 10);
9037 try expect(v[473] == 11);
9038 try expect(v[474] == 12);
9039 try expect(v[475] == 13);
9040 try expect(v[476] == 14);
9041 try expect(v[477] == 15);
9042 try expect(v[478] == 16);
9043 try expect(v[479] == 17);
9044 try expect(v[480] == 18);
9045 try expect(v[481] == 19);
9046 try expect(v[482] == 20);
9047 try expect(v[483] == 21);
9048 try expect(v[484] == 22);
9049 try expect(v[485] == 23);
9050 try expect(v[486] == 24);
9051 try expect(v[487] == 25);
9052 try expect(v[488] == 26);
9053 try expect(v[489] == 27);
9054 try expect(v[490] == 28);
9055 try expect(v[491] == 29);
9056 try expect(v[492] == 30);
9057 try expect(v[493] == 31);
9058 try expect(v[494] == 32);
9059 try expect(v[495] == 33);
9060 try expect(v[496] == 34);
9061 try expect(v[497] == 35);
9062 try expect(v[498] == 36);
9063 try expect(v[499] == 37);
9064 try expect(v[500] == 38);
9065 try expect(v[501] == 39);
9066 try expect(v[502] == 40);
9067 try expect(v[503] == 41);
9068 try expect(v[504] == 42);
9069 try expect(v[505] == 43);
9070 try expect(v[506] == 44);
9071 try expect(v[507] == 45);
9072 try expect(v[508] == 46);
9073 try expect(v[509] == 47);
9074 try expect(v[510] == 48);
9075 try expect(v[511] == 49);
9076 c_vector_512_u8(.{
9077 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
9078 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
9079 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
9080 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
9081 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
9082 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
9083 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
9084 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
9085 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
9086 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
9087 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
9088 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
9089 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
9090 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
9091 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
9092 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
9093 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
9094 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
9095 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
9096 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
9097 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
9098 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
9099 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
9100 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
9101 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
9102 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
9103 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
9104 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
9105 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
9106 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
9107 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
9108 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
9109 }, 512);
9110 c_test_vector_512_u8();
9111}
9112
9113export fn zig_ret_vector_1_u16() @Vector(1, u16) {
9114 return .{1};
9115}
9116export fn zig_vector_1_u16(v: @Vector(1, u16), i: usize) void {
9117 expect(v[0] == 2) catch @panic("test failure");
9118 expect(i == 1) catch @panic("test failure");
9119}
9120
9121extern fn c_ret_vector_1_u16() @Vector(1, u16);
9122extern fn c_vector_1_u16(@Vector(1, u16), usize) void;
9123extern fn c_test_vector_1_u16() void;
9124
9125test "@Vector(1, u16)" {
9126 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
9127 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9128 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9129
9130 const v = c_ret_vector_1_u16();
9131 try expect(v[0] == 3);
9132 c_vector_1_u16(.{4}, 1);
9133 c_test_vector_1_u16();
9134}
9135
9136export fn zig_ret_vector_2_u16() @Vector(2, u16) {
9137 return .{ 5, 6 };
9138}
9139export fn zig_vector_2_u16(v: @Vector(2, u16), i: usize) void {
9140 expect(v[0] == 7) catch @panic("test failure");
9141 expect(v[1] == 8) catch @panic("test failure");
9142 expect(i == 2) catch @panic("test failure");
9143}
9144
9145extern fn c_ret_vector_2_u16() @Vector(2, u16);
9146extern fn c_vector_2_u16(@Vector(2, u16), usize) void;
9147extern fn c_test_vector_2_u16() void;
9148
9149test "@Vector(2, u16)" {
9150 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
9151 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9152 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9153 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
9154 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9155 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
9156
9157 const v = c_ret_vector_2_u16();
9158 try expect(v[0] == 9);
9159 try expect(v[1] == 10);
9160 c_vector_2_u16(.{ 11, 12 }, 2);
9161 c_test_vector_2_u16();
9162}
9163
9164export fn zig_ret_vector_3_u16() @Vector(3, u16) {
9165 return .{ 13, 14, 15 };
9166}
9167export fn zig_vector_3_u16(v: @Vector(3, u16), i: usize) void {
9168 expect(v[0] == 16) catch @panic("test failure");
9169 expect(v[1] == 17) catch @panic("test failure");
9170 expect(v[2] == 18) catch @panic("test failure");
9171 expect(i == 3) catch @panic("test failure");
9172}
9173
9174extern fn c_ret_vector_3_u16() @Vector(3, u16);
9175extern fn c_vector_3_u16(@Vector(3, u16), usize) void;
9176extern fn c_test_vector_3_u16() void;
9177
9178test "@Vector(3, u16)" {
9179 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
9180 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9181 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9182 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9183
9184 const v = c_ret_vector_3_u16();
9185 try expect(v[0] == 19);
9186 try expect(v[1] == 20);
9187 try expect(v[2] == 21);
9188 c_vector_3_u16(.{ 22, 23, 24 }, 3);
9189 c_test_vector_3_u16();
9190}
9191
9192export fn zig_ret_vector_4_u16() @Vector(4, u16) {
9193 return .{ 25, 26, 27, 28 };
9194}
9195export fn zig_vector_4_u16(v: @Vector(4, u16), i: usize) void {
9196 expect(v[0] == 29) catch @panic("test failure");
9197 expect(v[1] == 30) catch @panic("test failure");
9198 expect(v[2] == 31) catch @panic("test failure");
9199 expect(v[3] == 32) catch @panic("test failure");
9200 expect(i == 4) catch @panic("test failure");
9201}
9202export fn zig_vector_4_u16_vector_4_u16(v0: @Vector(4, u16), v1: @Vector(4, u16), i: usize) void {
9203 expect(v0[0] == 33) catch @panic("test failure");
9204 expect(v0[1] == 34) catch @panic("test failure");
9205 expect(v0[2] == 35) catch @panic("test failure");
9206 expect(v0[3] == 36) catch @panic("test failure");
9207 expect(v1[0] == 37) catch @panic("test failure");
9208 expect(v1[1] == 38) catch @panic("test failure");
9209 expect(v1[2] == 39) catch @panic("test failure");
9210 expect(v1[3] == 40) catch @panic("test failure");
9211 expect(i == 8) catch @panic("test failure");
9212}
9213
9214extern fn c_ret_vector_4_u16() @Vector(4, u16);
9215extern fn c_vector_4_u16(@Vector(4, u16), usize) void;
9216extern fn c_vector_4_u16_vector_4_u16(@Vector(4, u16), @Vector(4, u16), usize) void;
9217extern fn c_test_vector_4_u16() void;
9218
9219test "@Vector(4, u16)" {
9220 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9221 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9222 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
9223 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
9224
9225 const v = c_ret_vector_4_u16();
9226 try expect(v[0] == 41);
9227 try expect(v[1] == 42);
9228 try expect(v[2] == 43);
9229 try expect(v[3] == 44);
9230 c_vector_4_u16(.{ 45, 46, 47, 48 }, 4);
9231 c_vector_4_u16_vector_4_u16(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
9232 c_test_vector_4_u16();
9233}
9234
9235export fn zig_ret_vector_6_u16() @Vector(6, u16) {
9236 return .{ 41, 42, 43, 44, 45, 46 };
9237}
9238export fn zig_vector_6_u16(v: @Vector(6, u16), i: usize) void {
9239 expect(v[0] == 47) catch @panic("test failure");
9240 expect(v[1] == 48) catch @panic("test failure");
9241 expect(v[2] == 49) catch @panic("test failure");
9242 expect(v[3] == 50) catch @panic("test failure");
9243 expect(v[4] == 51) catch @panic("test failure");
9244 expect(v[5] == 52) catch @panic("test failure");
9245 expect(i == 6) catch @panic("test failure");
9246}
9247
9248extern fn c_ret_vector_6_u16() @Vector(6, u16);
9249extern fn c_vector_6_u16(@Vector(6, u16), usize) void;
9250extern fn c_test_vector_6_u16() void;
9251
9252test "@Vector(6, u16)" {
9253 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
9254 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9255 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9256
9257 const v = c_ret_vector_6_u16();
9258 try expect(v[0] == 53);
9259 try expect(v[1] == 54);
9260 try expect(v[2] == 55);
9261 try expect(v[3] == 56);
9262 try expect(v[4] == 57);
9263 try expect(v[5] == 58);
9264 c_vector_6_u16(.{ 59, 60, 61, 62, 63, 64 }, 6);
9265 c_test_vector_6_u16();
9266}
9267
9268export fn zig_ret_vector_8_u16() @Vector(8, u16) {
9269 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
9270}
9271export fn zig_vector_8_u16(v: @Vector(8, u16), i: usize) void {
9272 expect(v[0] == 73) catch @panic("test failure");
9273 expect(v[1] == 74) catch @panic("test failure");
9274 expect(v[2] == 75) catch @panic("test failure");
9275 expect(v[3] == 76) catch @panic("test failure");
9276 expect(v[4] == 77) catch @panic("test failure");
9277 expect(v[5] == 78) catch @panic("test failure");
9278 expect(v[6] == 79) catch @panic("test failure");
9279 expect(v[7] == 80) catch @panic("test failure");
9280 expect(i == 8) catch @panic("test failure");
9281}
9282
9283extern fn c_ret_vector_8_u16() @Vector(8, u16);
9284extern fn c_vector_8_u16(@Vector(8, u16), usize) void;
9285extern fn c_test_vector_8_u16() void;
9286
9287test "@Vector(8, u16)" {
9288 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9289
9290 const v = c_ret_vector_8_u16();
9291 try expect(v[0] == 81);
9292 try expect(v[1] == 82);
9293 try expect(v[2] == 83);
9294 try expect(v[3] == 84);
9295 try expect(v[4] == 85);
9296 try expect(v[5] == 86);
9297 try expect(v[6] == 87);
9298 try expect(v[7] == 88);
9299 c_vector_8_u16(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
9300 c_test_vector_8_u16();
9301}
9302
9303export fn zig_ret_vector_12_u16() @Vector(12, u16) {
9304 return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
9305}
9306export fn zig_vector_12_u16(v: @Vector(12, u16), i: usize) void {
9307 expect(v[0] == 109) catch @panic("test failure");
9308 expect(v[1] == 110) catch @panic("test failure");
9309 expect(v[2] == 111) catch @panic("test failure");
9310 expect(v[3] == 112) catch @panic("test failure");
9311 expect(v[4] == 113) catch @panic("test failure");
9312 expect(v[5] == 114) catch @panic("test failure");
9313 expect(v[6] == 115) catch @panic("test failure");
9314 expect(v[7] == 116) catch @panic("test failure");
9315 expect(v[8] == 117) catch @panic("test failure");
9316 expect(v[9] == 118) catch @panic("test failure");
9317 expect(v[10] == 119) catch @panic("test failure");
9318 expect(v[11] == 120) catch @panic("test failure");
9319 expect(i == 12) catch @panic("test failure");
9320}
9321
9322extern fn c_ret_vector_12_u16() @Vector(12, u16);
9323extern fn c_vector_12_u16(@Vector(12, u16), usize) void;
9324extern fn c_test_vector_12_u16() void;
9325
9326test "@Vector(12, u16)" {
9327 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9328 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9329 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9330 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9331
9332 const v = c_ret_vector_12_u16();
9333 try expect(v[0] == 121);
9334 try expect(v[1] == 122);
9335 try expect(v[2] == 123);
9336 try expect(v[3] == 124);
9337 try expect(v[4] == 125);
9338 try expect(v[5] == 126);
9339 try expect(v[6] == 127);
9340 try expect(v[7] == 128);
9341 try expect(v[8] == 129);
9342 try expect(v[9] == 130);
9343 try expect(v[10] == 131);
9344 try expect(v[11] == 132);
9345 c_vector_12_u16(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
9346 c_test_vector_12_u16();
9347}
9348
9349export fn zig_ret_vector_16_u16() @Vector(16, u16) {
9350 return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
9351}
9352export fn zig_vector_16_u16(v: @Vector(16, u16), i: usize) void {
9353 expect(v[0] == 161) catch @panic("test failure");
9354 expect(v[1] == 162) catch @panic("test failure");
9355 expect(v[2] == 163) catch @panic("test failure");
9356 expect(v[3] == 164) catch @panic("test failure");
9357 expect(v[4] == 165) catch @panic("test failure");
9358 expect(v[5] == 166) catch @panic("test failure");
9359 expect(v[6] == 167) catch @panic("test failure");
9360 expect(v[7] == 168) catch @panic("test failure");
9361 expect(v[8] == 169) catch @panic("test failure");
9362 expect(v[9] == 170) catch @panic("test failure");
9363 expect(v[10] == 171) catch @panic("test failure");
9364 expect(v[11] == 172) catch @panic("test failure");
9365 expect(v[12] == 173) catch @panic("test failure");
9366 expect(v[13] == 174) catch @panic("test failure");
9367 expect(v[14] == 175) catch @panic("test failure");
9368 expect(v[15] == 176) catch @panic("test failure");
9369 expect(i == 16) catch @panic("test failure");
9370}
9371
9372extern fn c_ret_vector_16_u16() @Vector(16, u16);
9373extern fn c_vector_16_u16(@Vector(16, u16), usize) void;
9374extern fn c_test_vector_16_u16() void;
9375
9376test "@Vector(16, u16)" {
9377 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9378 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9379 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9380
9381 const v = c_ret_vector_16_u16();
9382 try expect(v[0] == 177);
9383 try expect(v[1] == 178);
9384 try expect(v[2] == 179);
9385 try expect(v[3] == 180);
9386 try expect(v[4] == 181);
9387 try expect(v[5] == 182);
9388 try expect(v[6] == 183);
9389 try expect(v[7] == 184);
9390 try expect(v[8] == 185);
9391 try expect(v[9] == 186);
9392 try expect(v[10] == 187);
9393 try expect(v[11] == 188);
9394 try expect(v[12] == 189);
9395 try expect(v[13] == 190);
9396 try expect(v[14] == 191);
9397 try expect(v[15] == 192);
9398 c_vector_16_u16(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
9399 c_test_vector_16_u16();
9400}
9401
9402export fn zig_ret_vector_24_u16() @Vector(24, u16) {
9403 return .{
9404 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
9405 225, 226, 227, 228, 229, 230, 231, 232,
9406 };
9407}
9408export fn zig_vector_24_u16(v: @Vector(24, u16), i: usize) void {
9409 expect(v[0] == 233) catch @panic("test failure");
9410 expect(v[1] == 234) catch @panic("test failure");
9411 expect(v[2] == 235) catch @panic("test failure");
9412 expect(v[3] == 236) catch @panic("test failure");
9413 expect(v[4] == 237) catch @panic("test failure");
9414 expect(v[5] == 238) catch @panic("test failure");
9415 expect(v[6] == 239) catch @panic("test failure");
9416 expect(v[7] == 240) catch @panic("test failure");
9417 expect(v[8] == 241) catch @panic("test failure");
9418 expect(v[9] == 242) catch @panic("test failure");
9419 expect(v[10] == 243) catch @panic("test failure");
9420 expect(v[11] == 244) catch @panic("test failure");
9421 expect(v[12] == 245) catch @panic("test failure");
9422 expect(v[13] == 246) catch @panic("test failure");
9423 expect(v[14] == 247) catch @panic("test failure");
9424 expect(v[15] == 248) catch @panic("test failure");
9425 expect(v[16] == 249) catch @panic("test failure");
9426 expect(v[17] == 250) catch @panic("test failure");
9427 expect(v[18] == 251) catch @panic("test failure");
9428 expect(v[19] == 252) catch @panic("test failure");
9429 expect(v[20] == 253) catch @panic("test failure");
9430 expect(v[21] == 254) catch @panic("test failure");
9431 expect(v[22] == 255) catch @panic("test failure");
9432 expect(v[23] == 256) catch @panic("test failure");
9433 expect(i == 24) catch @panic("test failure");
9434}
9435
9436extern fn c_ret_vector_24_u16() @Vector(24, u16);
9437extern fn c_vector_24_u16(@Vector(24, u16), usize) void;
9438extern fn c_test_vector_24_u16() void;
9439
9440test "@Vector(24, u16)" {
9441 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9442 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9443 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9444 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9445
9446 const v = c_ret_vector_24_u16();
9447 try expect(v[0] == 257);
9448 try expect(v[1] == 258);
9449 try expect(v[2] == 259);
9450 try expect(v[3] == 260);
9451 try expect(v[4] == 261);
9452 try expect(v[5] == 262);
9453 try expect(v[6] == 263);
9454 try expect(v[7] == 264);
9455 try expect(v[8] == 265);
9456 try expect(v[9] == 266);
9457 try expect(v[10] == 267);
9458 try expect(v[11] == 268);
9459 try expect(v[12] == 269);
9460 try expect(v[13] == 270);
9461 try expect(v[14] == 271);
9462 try expect(v[15] == 272);
9463 try expect(v[16] == 273);
9464 try expect(v[17] == 274);
9465 try expect(v[18] == 275);
9466 try expect(v[19] == 276);
9467 try expect(v[20] == 277);
9468 try expect(v[21] == 278);
9469 try expect(v[22] == 279);
9470 try expect(v[23] == 280);
9471 c_vector_24_u16(.{
9472 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
9473 297, 298, 299, 300, 301, 302, 303, 304,
9474 }, 24);
9475 c_test_vector_24_u16();
9476}
9477
9478export fn zig_ret_vector_32_u16() @Vector(32, u16) {
9479 return .{
9480 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
9481 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
9482 };
9483}
9484export fn zig_vector_32_u16(v: @Vector(32, u16), i: usize) void {
9485 expect(v[0] == 337) catch @panic("test failure");
9486 expect(v[1] == 338) catch @panic("test failure");
9487 expect(v[2] == 339) catch @panic("test failure");
9488 expect(v[3] == 340) catch @panic("test failure");
9489 expect(v[4] == 341) catch @panic("test failure");
9490 expect(v[5] == 342) catch @panic("test failure");
9491 expect(v[6] == 343) catch @panic("test failure");
9492 expect(v[7] == 344) catch @panic("test failure");
9493 expect(v[8] == 345) catch @panic("test failure");
9494 expect(v[9] == 346) catch @panic("test failure");
9495 expect(v[10] == 347) catch @panic("test failure");
9496 expect(v[11] == 348) catch @panic("test failure");
9497 expect(v[12] == 349) catch @panic("test failure");
9498 expect(v[13] == 350) catch @panic("test failure");
9499 expect(v[14] == 351) catch @panic("test failure");
9500 expect(v[15] == 352) catch @panic("test failure");
9501 expect(v[16] == 353) catch @panic("test failure");
9502 expect(v[17] == 354) catch @panic("test failure");
9503 expect(v[18] == 355) catch @panic("test failure");
9504 expect(v[19] == 356) catch @panic("test failure");
9505 expect(v[20] == 357) catch @panic("test failure");
9506 expect(v[21] == 358) catch @panic("test failure");
9507 expect(v[22] == 359) catch @panic("test failure");
9508 expect(v[23] == 360) catch @panic("test failure");
9509 expect(v[24] == 361) catch @panic("test failure");
9510 expect(v[25] == 362) catch @panic("test failure");
9511 expect(v[26] == 363) catch @panic("test failure");
9512 expect(v[27] == 364) catch @panic("test failure");
9513 expect(v[28] == 365) catch @panic("test failure");
9514 expect(v[29] == 366) catch @panic("test failure");
9515 expect(v[30] == 367) catch @panic("test failure");
9516 expect(v[31] == 368) catch @panic("test failure");
9517 expect(i == 32) catch @panic("test failure");
9518}
9519
9520extern fn c_ret_vector_32_u16() @Vector(32, u16);
9521extern fn c_vector_32_u16(@Vector(32, u16), usize) void;
9522extern fn c_test_vector_32_u16() void;
9523
9524test "@Vector(32, u16)" {
9525 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9526 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9527 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9528
9529 const v = c_ret_vector_32_u16();
9530 try expect(v[0] == 369);
9531 try expect(v[1] == 370);
9532 try expect(v[2] == 371);
9533 try expect(v[3] == 372);
9534 try expect(v[4] == 373);
9535 try expect(v[5] == 374);
9536 try expect(v[6] == 375);
9537 try expect(v[7] == 376);
9538 try expect(v[8] == 377);
9539 try expect(v[9] == 378);
9540 try expect(v[10] == 379);
9541 try expect(v[11] == 380);
9542 try expect(v[12] == 381);
9543 try expect(v[13] == 382);
9544 try expect(v[14] == 383);
9545 try expect(v[15] == 384);
9546 try expect(v[16] == 385);
9547 try expect(v[17] == 386);
9548 try expect(v[18] == 387);
9549 try expect(v[19] == 388);
9550 try expect(v[20] == 389);
9551 try expect(v[21] == 390);
9552 try expect(v[22] == 391);
9553 try expect(v[23] == 392);
9554 try expect(v[24] == 393);
9555 try expect(v[25] == 394);
9556 try expect(v[26] == 395);
9557 try expect(v[27] == 396);
9558 try expect(v[28] == 397);
9559 try expect(v[29] == 398);
9560 try expect(v[30] == 399);
9561 try expect(v[31] == 400);
9562 c_vector_32_u16(.{
9563 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
9564 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
9565 }, 32);
9566 c_test_vector_32_u16();
9567}
9568
9569export fn zig_ret_vector_48_u16() @Vector(48, u16) {
9570 return .{
9571 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
9572 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
9573 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
9574 };
9575}
9576export fn zig_vector_48_u16(v: @Vector(48, u16), i: usize) void {
9577 expect(v[0] == 481) catch @panic("test failure");
9578 expect(v[1] == 482) catch @panic("test failure");
9579 expect(v[2] == 483) catch @panic("test failure");
9580 expect(v[3] == 484) catch @panic("test failure");
9581 expect(v[4] == 485) catch @panic("test failure");
9582 expect(v[5] == 486) catch @panic("test failure");
9583 expect(v[6] == 487) catch @panic("test failure");
9584 expect(v[7] == 488) catch @panic("test failure");
9585 expect(v[8] == 489) catch @panic("test failure");
9586 expect(v[9] == 490) catch @panic("test failure");
9587 expect(v[10] == 491) catch @panic("test failure");
9588 expect(v[11] == 492) catch @panic("test failure");
9589 expect(v[12] == 493) catch @panic("test failure");
9590 expect(v[13] == 494) catch @panic("test failure");
9591 expect(v[14] == 495) catch @panic("test failure");
9592 expect(v[15] == 496) catch @panic("test failure");
9593 expect(v[16] == 497) catch @panic("test failure");
9594 expect(v[17] == 498) catch @panic("test failure");
9595 expect(v[18] == 499) catch @panic("test failure");
9596 expect(v[19] == 500) catch @panic("test failure");
9597 expect(v[20] == 501) catch @panic("test failure");
9598 expect(v[21] == 502) catch @panic("test failure");
9599 expect(v[22] == 503) catch @panic("test failure");
9600 expect(v[23] == 504) catch @panic("test failure");
9601 expect(v[24] == 505) catch @panic("test failure");
9602 expect(v[25] == 506) catch @panic("test failure");
9603 expect(v[26] == 507) catch @panic("test failure");
9604 expect(v[27] == 508) catch @panic("test failure");
9605 expect(v[28] == 509) catch @panic("test failure");
9606 expect(v[29] == 510) catch @panic("test failure");
9607 expect(v[30] == 511) catch @panic("test failure");
9608 expect(v[31] == 512) catch @panic("test failure");
9609 expect(v[32] == 513) catch @panic("test failure");
9610 expect(v[33] == 514) catch @panic("test failure");
9611 expect(v[34] == 515) catch @panic("test failure");
9612 expect(v[35] == 516) catch @panic("test failure");
9613 expect(v[36] == 517) catch @panic("test failure");
9614 expect(v[37] == 518) catch @panic("test failure");
9615 expect(v[38] == 519) catch @panic("test failure");
9616 expect(v[39] == 520) catch @panic("test failure");
9617 expect(v[40] == 521) catch @panic("test failure");
9618 expect(v[41] == 522) catch @panic("test failure");
9619 expect(v[42] == 523) catch @panic("test failure");
9620 expect(v[43] == 524) catch @panic("test failure");
9621 expect(v[44] == 525) catch @panic("test failure");
9622 expect(v[45] == 526) catch @panic("test failure");
9623 expect(v[46] == 527) catch @panic("test failure");
9624 expect(v[47] == 528) catch @panic("test failure");
9625 expect(i == 48) catch @panic("test failure");
9626}
9627
9628extern fn c_ret_vector_48_u16() @Vector(48, u16);
9629extern fn c_vector_48_u16(@Vector(48, u16), usize) void;
9630extern fn c_test_vector_48_u16() void;
9631
9632test "@Vector(48, u16)" {
9633 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9634 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9635 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9636 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9637
9638 const v = c_ret_vector_48_u16();
9639 try expect(v[0] == 529);
9640 try expect(v[1] == 530);
9641 try expect(v[2] == 531);
9642 try expect(v[3] == 532);
9643 try expect(v[4] == 533);
9644 try expect(v[5] == 534);
9645 try expect(v[6] == 535);
9646 try expect(v[7] == 536);
9647 try expect(v[8] == 537);
9648 try expect(v[9] == 538);
9649 try expect(v[10] == 539);
9650 try expect(v[11] == 540);
9651 try expect(v[12] == 541);
9652 try expect(v[13] == 542);
9653 try expect(v[14] == 543);
9654 try expect(v[15] == 544);
9655 try expect(v[16] == 545);
9656 try expect(v[17] == 546);
9657 try expect(v[18] == 547);
9658 try expect(v[19] == 548);
9659 try expect(v[20] == 549);
9660 try expect(v[21] == 550);
9661 try expect(v[22] == 551);
9662 try expect(v[23] == 552);
9663 try expect(v[24] == 553);
9664 try expect(v[25] == 554);
9665 try expect(v[26] == 555);
9666 try expect(v[27] == 556);
9667 try expect(v[28] == 557);
9668 try expect(v[29] == 558);
9669 try expect(v[30] == 559);
9670 try expect(v[31] == 560);
9671 try expect(v[32] == 561);
9672 try expect(v[33] == 562);
9673 try expect(v[34] == 563);
9674 try expect(v[35] == 564);
9675 try expect(v[36] == 565);
9676 try expect(v[37] == 566);
9677 try expect(v[38] == 567);
9678 try expect(v[39] == 568);
9679 try expect(v[40] == 569);
9680 try expect(v[41] == 570);
9681 try expect(v[42] == 571);
9682 try expect(v[43] == 572);
9683 try expect(v[44] == 573);
9684 try expect(v[45] == 574);
9685 try expect(v[46] == 575);
9686 try expect(v[47] == 576);
9687 c_vector_48_u16(.{
9688 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
9689 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
9690 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
9691 }, 48);
9692 c_test_vector_48_u16();
9693}
9694
9695export fn zig_ret_vector_64_u16() @Vector(64, u16) {
9696 return .{
9697 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
9698 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
9699 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
9700 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
9701 };
9702}
9703export fn zig_vector_64_u16(v: @Vector(64, u16), i: usize) void {
9704 expect(v[0] == 689) catch @panic("test failure");
9705 expect(v[1] == 690) catch @panic("test failure");
9706 expect(v[2] == 691) catch @panic("test failure");
9707 expect(v[3] == 692) catch @panic("test failure");
9708 expect(v[4] == 693) catch @panic("test failure");
9709 expect(v[5] == 694) catch @panic("test failure");
9710 expect(v[6] == 695) catch @panic("test failure");
9711 expect(v[7] == 696) catch @panic("test failure");
9712 expect(v[8] == 697) catch @panic("test failure");
9713 expect(v[9] == 698) catch @panic("test failure");
9714 expect(v[10] == 699) catch @panic("test failure");
9715 expect(v[11] == 700) catch @panic("test failure");
9716 expect(v[12] == 701) catch @panic("test failure");
9717 expect(v[13] == 702) catch @panic("test failure");
9718 expect(v[14] == 703) catch @panic("test failure");
9719 expect(v[15] == 704) catch @panic("test failure");
9720 expect(v[16] == 705) catch @panic("test failure");
9721 expect(v[17] == 706) catch @panic("test failure");
9722 expect(v[18] == 707) catch @panic("test failure");
9723 expect(v[19] == 708) catch @panic("test failure");
9724 expect(v[20] == 709) catch @panic("test failure");
9725 expect(v[21] == 710) catch @panic("test failure");
9726 expect(v[22] == 711) catch @panic("test failure");
9727 expect(v[23] == 712) catch @panic("test failure");
9728 expect(v[24] == 713) catch @panic("test failure");
9729 expect(v[25] == 714) catch @panic("test failure");
9730 expect(v[26] == 715) catch @panic("test failure");
9731 expect(v[27] == 716) catch @panic("test failure");
9732 expect(v[28] == 717) catch @panic("test failure");
9733 expect(v[29] == 718) catch @panic("test failure");
9734 expect(v[30] == 719) catch @panic("test failure");
9735 expect(v[31] == 720) catch @panic("test failure");
9736 expect(v[32] == 721) catch @panic("test failure");
9737 expect(v[33] == 722) catch @panic("test failure");
9738 expect(v[34] == 723) catch @panic("test failure");
9739 expect(v[35] == 724) catch @panic("test failure");
9740 expect(v[36] == 725) catch @panic("test failure");
9741 expect(v[37] == 726) catch @panic("test failure");
9742 expect(v[38] == 727) catch @panic("test failure");
9743 expect(v[39] == 728) catch @panic("test failure");
9744 expect(v[40] == 729) catch @panic("test failure");
9745 expect(v[41] == 730) catch @panic("test failure");
9746 expect(v[42] == 731) catch @panic("test failure");
9747 expect(v[43] == 732) catch @panic("test failure");
9748 expect(v[44] == 733) catch @panic("test failure");
9749 expect(v[45] == 734) catch @panic("test failure");
9750 expect(v[46] == 735) catch @panic("test failure");
9751 expect(v[47] == 736) catch @panic("test failure");
9752 expect(v[48] == 737) catch @panic("test failure");
9753 expect(v[49] == 738) catch @panic("test failure");
9754 expect(v[50] == 739) catch @panic("test failure");
9755 expect(v[51] == 740) catch @panic("test failure");
9756 expect(v[52] == 741) catch @panic("test failure");
9757 expect(v[53] == 742) catch @panic("test failure");
9758 expect(v[54] == 743) catch @panic("test failure");
9759 expect(v[55] == 744) catch @panic("test failure");
9760 expect(v[56] == 745) catch @panic("test failure");
9761 expect(v[57] == 746) catch @panic("test failure");
9762 expect(v[58] == 747) catch @panic("test failure");
9763 expect(v[59] == 748) catch @panic("test failure");
9764 expect(v[60] == 749) catch @panic("test failure");
9765 expect(v[61] == 750) catch @panic("test failure");
9766 expect(v[62] == 751) catch @panic("test failure");
9767 expect(v[63] == 752) catch @panic("test failure");
9768 expect(i == 64) catch @panic("test failure");
9769}
9770
9771extern fn c_ret_vector_64_u16() @Vector(64, u16);
9772extern fn c_vector_64_u16(@Vector(64, u16), usize) void;
9773extern fn c_test_vector_64_u16() void;
9774
9775test "@Vector(64, u16)" {
9776 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9777 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9778 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
9779 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9780
9781 const v = c_ret_vector_64_u16();
9782 try expect(v[0] == 753);
9783 try expect(v[1] == 754);
9784 try expect(v[2] == 755);
9785 try expect(v[3] == 756);
9786 try expect(v[4] == 757);
9787 try expect(v[5] == 758);
9788 try expect(v[6] == 759);
9789 try expect(v[7] == 760);
9790 try expect(v[8] == 761);
9791 try expect(v[9] == 762);
9792 try expect(v[10] == 763);
9793 try expect(v[11] == 764);
9794 try expect(v[12] == 765);
9795 try expect(v[13] == 766);
9796 try expect(v[14] == 767);
9797 try expect(v[15] == 768);
9798 try expect(v[16] == 769);
9799 try expect(v[17] == 770);
9800 try expect(v[18] == 771);
9801 try expect(v[19] == 772);
9802 try expect(v[20] == 773);
9803 try expect(v[21] == 774);
9804 try expect(v[22] == 775);
9805 try expect(v[23] == 776);
9806 try expect(v[24] == 777);
9807 try expect(v[25] == 778);
9808 try expect(v[26] == 779);
9809 try expect(v[27] == 780);
9810 try expect(v[28] == 781);
9811 try expect(v[29] == 782);
9812 try expect(v[30] == 783);
9813 try expect(v[31] == 784);
9814 try expect(v[32] == 785);
9815 try expect(v[33] == 786);
9816 try expect(v[34] == 787);
9817 try expect(v[35] == 788);
9818 try expect(v[36] == 789);
9819 try expect(v[37] == 790);
9820 try expect(v[38] == 791);
9821 try expect(v[39] == 792);
9822 try expect(v[40] == 793);
9823 try expect(v[41] == 794);
9824 try expect(v[42] == 795);
9825 try expect(v[43] == 796);
9826 try expect(v[44] == 797);
9827 try expect(v[45] == 798);
9828 try expect(v[46] == 799);
9829 try expect(v[47] == 800);
9830 try expect(v[48] == 801);
9831 try expect(v[49] == 802);
9832 try expect(v[50] == 803);
9833 try expect(v[51] == 804);
9834 try expect(v[52] == 805);
9835 try expect(v[53] == 806);
9836 try expect(v[54] == 807);
9837 try expect(v[55] == 808);
9838 try expect(v[56] == 809);
9839 try expect(v[57] == 810);
9840 try expect(v[58] == 811);
9841 try expect(v[59] == 812);
9842 try expect(v[60] == 813);
9843 try expect(v[61] == 814);
9844 try expect(v[62] == 815);
9845 try expect(v[63] == 816);
9846 c_vector_64_u16(.{
9847 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
9848 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
9849 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
9850 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
9851 }, 64);
9852 c_test_vector_64_u16();
9853}
9854
9855export fn zig_ret_vector_96_u16() @Vector(96, u16) {
9856 return .{
9857 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
9858 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
9859 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
9860 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
9861 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
9862 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
9863 };
9864}
9865export fn zig_vector_96_u16(v: @Vector(96, u16), i: usize) void {
9866 expect(v[0] == 986) catch @panic("test failure");
9867 expect(v[1] == 987) catch @panic("test failure");
9868 expect(v[2] == 988) catch @panic("test failure");
9869 expect(v[3] == 989) catch @panic("test failure");
9870 expect(v[4] == 990) catch @panic("test failure");
9871 expect(v[5] == 991) catch @panic("test failure");
9872 expect(v[6] == 992) catch @panic("test failure");
9873 expect(v[7] == 993) catch @panic("test failure");
9874 expect(v[8] == 994) catch @panic("test failure");
9875 expect(v[9] == 995) catch @panic("test failure");
9876 expect(v[10] == 996) catch @panic("test failure");
9877 expect(v[11] == 997) catch @panic("test failure");
9878 expect(v[12] == 998) catch @panic("test failure");
9879 expect(v[13] == 999) catch @panic("test failure");
9880 expect(v[14] == 1000) catch @panic("test failure");
9881 expect(v[15] == 1001) catch @panic("test failure");
9882 expect(v[16] == 1002) catch @panic("test failure");
9883 expect(v[17] == 1003) catch @panic("test failure");
9884 expect(v[18] == 1004) catch @panic("test failure");
9885 expect(v[19] == 1005) catch @panic("test failure");
9886 expect(v[20] == 1006) catch @panic("test failure");
9887 expect(v[21] == 1007) catch @panic("test failure");
9888 expect(v[22] == 1008) catch @panic("test failure");
9889 expect(v[23] == 1009) catch @panic("test failure");
9890 expect(v[24] == 1010) catch @panic("test failure");
9891 expect(v[25] == 1011) catch @panic("test failure");
9892 expect(v[26] == 1012) catch @panic("test failure");
9893 expect(v[27] == 1013) catch @panic("test failure");
9894 expect(v[28] == 1014) catch @panic("test failure");
9895 expect(v[29] == 1015) catch @panic("test failure");
9896 expect(v[30] == 1016) catch @panic("test failure");
9897 expect(v[31] == 1017) catch @panic("test failure");
9898 expect(v[32] == 1018) catch @panic("test failure");
9899 expect(v[33] == 1019) catch @panic("test failure");
9900 expect(v[34] == 1020) catch @panic("test failure");
9901 expect(v[35] == 1021) catch @panic("test failure");
9902 expect(v[36] == 1022) catch @panic("test failure");
9903 expect(v[37] == 1023) catch @panic("test failure");
9904 expect(v[38] == 1024) catch @panic("test failure");
9905 expect(v[39] == 1025) catch @panic("test failure");
9906 expect(v[40] == 1026) catch @panic("test failure");
9907 expect(v[41] == 1027) catch @panic("test failure");
9908 expect(v[42] == 1028) catch @panic("test failure");
9909 expect(v[43] == 1029) catch @panic("test failure");
9910 expect(v[44] == 1030) catch @panic("test failure");
9911 expect(v[45] == 1031) catch @panic("test failure");
9912 expect(v[46] == 1032) catch @panic("test failure");
9913 expect(v[47] == 1033) catch @panic("test failure");
9914 expect(v[48] == 1034) catch @panic("test failure");
9915 expect(v[49] == 1035) catch @panic("test failure");
9916 expect(v[50] == 1036) catch @panic("test failure");
9917 expect(v[51] == 1037) catch @panic("test failure");
9918 expect(v[52] == 1038) catch @panic("test failure");
9919 expect(v[53] == 1039) catch @panic("test failure");
9920 expect(v[54] == 1040) catch @panic("test failure");
9921 expect(v[55] == 1041) catch @panic("test failure");
9922 expect(v[56] == 1042) catch @panic("test failure");
9923 expect(v[57] == 1043) catch @panic("test failure");
9924 expect(v[58] == 1044) catch @panic("test failure");
9925 expect(v[59] == 1045) catch @panic("test failure");
9926 expect(v[60] == 1046) catch @panic("test failure");
9927 expect(v[61] == 1047) catch @panic("test failure");
9928 expect(v[62] == 1048) catch @panic("test failure");
9929 expect(v[63] == 1049) catch @panic("test failure");
9930 expect(v[64] == 1050) catch @panic("test failure");
9931 expect(v[65] == 1051) catch @panic("test failure");
9932 expect(v[66] == 1052) catch @panic("test failure");
9933 expect(v[67] == 1053) catch @panic("test failure");
9934 expect(v[68] == 1054) catch @panic("test failure");
9935 expect(v[69] == 1055) catch @panic("test failure");
9936 expect(v[70] == 1056) catch @panic("test failure");
9937 expect(v[71] == 1057) catch @panic("test failure");
9938 expect(v[72] == 1058) catch @panic("test failure");
9939 expect(v[73] == 1059) catch @panic("test failure");
9940 expect(v[74] == 1060) catch @panic("test failure");
9941 expect(v[75] == 1061) catch @panic("test failure");
9942 expect(v[76] == 1062) catch @panic("test failure");
9943 expect(v[77] == 1063) catch @panic("test failure");
9944 expect(v[78] == 1064) catch @panic("test failure");
9945 expect(v[79] == 1065) catch @panic("test failure");
9946 expect(v[80] == 1066) catch @panic("test failure");
9947 expect(v[81] == 1067) catch @panic("test failure");
9948 expect(v[82] == 1068) catch @panic("test failure");
9949 expect(v[83] == 1069) catch @panic("test failure");
9950 expect(v[84] == 1070) catch @panic("test failure");
9951 expect(v[85] == 1071) catch @panic("test failure");
9952 expect(v[86] == 1072) catch @panic("test failure");
9953 expect(v[87] == 1073) catch @panic("test failure");
9954 expect(v[88] == 1074) catch @panic("test failure");
9955 expect(v[89] == 1075) catch @panic("test failure");
9956 expect(v[90] == 1076) catch @panic("test failure");
9957 expect(v[91] == 1077) catch @panic("test failure");
9958 expect(v[92] == 1078) catch @panic("test failure");
9959 expect(v[93] == 1079) catch @panic("test failure");
9960 expect(v[94] == 1080) catch @panic("test failure");
9961 expect(v[95] == 1081) catch @panic("test failure");
9962 expect(i == 96) catch @panic("test failure");
9963}
9964
9965extern fn c_ret_vector_96_u16() @Vector(96, u16);
9966extern fn c_vector_96_u16(@Vector(96, u16), usize) void;
9967extern fn c_test_vector_96_u16() void;
9968
9969test "@Vector(96, u16)" {
9970 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
9971 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
9972 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
9973 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
9974
9975 const v = c_ret_vector_96_u16();
9976 try expect(v[0] == 1082);
9977 try expect(v[1] == 1083);
9978 try expect(v[2] == 1084);
9979 try expect(v[3] == 1085);
9980 try expect(v[4] == 1086);
9981 try expect(v[5] == 1087);
9982 try expect(v[6] == 1088);
9983 try expect(v[7] == 1089);
9984 try expect(v[8] == 1090);
9985 try expect(v[9] == 1091);
9986 try expect(v[10] == 1092);
9987 try expect(v[11] == 1093);
9988 try expect(v[12] == 1094);
9989 try expect(v[13] == 1095);
9990 try expect(v[14] == 1096);
9991 try expect(v[15] == 1097);
9992 try expect(v[16] == 1098);
9993 try expect(v[17] == 1099);
9994 try expect(v[18] == 1100);
9995 try expect(v[19] == 1101);
9996 try expect(v[20] == 1102);
9997 try expect(v[21] == 1103);
9998 try expect(v[22] == 1104);
9999 try expect(v[23] == 1105);
10000 try expect(v[24] == 1106);
10001 try expect(v[25] == 1107);
10002 try expect(v[26] == 1108);
10003 try expect(v[27] == 1109);
10004 try expect(v[28] == 1110);
10005 try expect(v[29] == 1111);
10006 try expect(v[30] == 1112);
10007 try expect(v[31] == 1113);
10008 try expect(v[32] == 1114);
10009 try expect(v[33] == 1115);
10010 try expect(v[34] == 1116);
10011 try expect(v[35] == 1117);
10012 try expect(v[36] == 1118);
10013 try expect(v[37] == 1119);
10014 try expect(v[38] == 1120);
10015 try expect(v[39] == 1121);
10016 try expect(v[40] == 1122);
10017 try expect(v[41] == 1123);
10018 try expect(v[42] == 1124);
10019 try expect(v[43] == 1125);
10020 try expect(v[44] == 1126);
10021 try expect(v[45] == 1127);
10022 try expect(v[46] == 1128);
10023 try expect(v[47] == 1129);
10024 try expect(v[48] == 1130);
10025 try expect(v[49] == 1131);
10026 try expect(v[50] == 1132);
10027 try expect(v[51] == 1133);
10028 try expect(v[52] == 1134);
10029 try expect(v[53] == 1135);
10030 try expect(v[54] == 1136);
10031 try expect(v[55] == 1137);
10032 try expect(v[56] == 1138);
10033 try expect(v[57] == 1139);
10034 try expect(v[58] == 1140);
10035 try expect(v[59] == 1141);
10036 try expect(v[60] == 1142);
10037 try expect(v[61] == 1143);
10038 try expect(v[62] == 1144);
10039 try expect(v[63] == 1145);
10040 try expect(v[64] == 1146);
10041 try expect(v[65] == 1147);
10042 try expect(v[66] == 1148);
10043 try expect(v[67] == 1149);
10044 try expect(v[68] == 1150);
10045 try expect(v[69] == 1151);
10046 try expect(v[70] == 1152);
10047 try expect(v[71] == 1153);
10048 try expect(v[72] == 1154);
10049 try expect(v[73] == 1155);
10050 try expect(v[74] == 1156);
10051 try expect(v[75] == 1157);
10052 try expect(v[76] == 1158);
10053 try expect(v[77] == 1159);
10054 try expect(v[78] == 1160);
10055 try expect(v[79] == 1161);
10056 try expect(v[80] == 1162);
10057 try expect(v[81] == 1163);
10058 try expect(v[82] == 1164);
10059 try expect(v[83] == 1165);
10060 try expect(v[84] == 1166);
10061 try expect(v[85] == 1167);
10062 try expect(v[86] == 1168);
10063 try expect(v[87] == 1169);
10064 try expect(v[88] == 1170);
10065 try expect(v[89] == 1171);
10066 try expect(v[90] == 1172);
10067 try expect(v[91] == 1173);
10068 try expect(v[92] == 1174);
10069 try expect(v[93] == 1175);
10070 try expect(v[94] == 1176);
10071 try expect(v[95] == 1177);
10072 c_vector_96_u16(.{
10073 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
10074 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
10075 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
10076 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
10077 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
10078 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
10079 }, 96);
10080 c_test_vector_96_u16();
10081}
10082
10083export fn zig_ret_vector_128_u16() @Vector(128, u16) {
10084 return .{
10085 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
10086 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
10087 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
10088 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
10089 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
10090 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
10091 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
10092 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
10093 };
10094}
10095export fn zig_vector_128_u16(v: @Vector(128, u16), i: usize) void {
10096 expect(v[0] == 1402) catch @panic("test failure");
10097 expect(v[1] == 1403) catch @panic("test failure");
10098 expect(v[2] == 1404) catch @panic("test failure");
10099 expect(v[3] == 1405) catch @panic("test failure");
10100 expect(v[4] == 1406) catch @panic("test failure");
10101 expect(v[5] == 1407) catch @panic("test failure");
10102 expect(v[6] == 1408) catch @panic("test failure");
10103 expect(v[7] == 1409) catch @panic("test failure");
10104 expect(v[8] == 1410) catch @panic("test failure");
10105 expect(v[9] == 1411) catch @panic("test failure");
10106 expect(v[10] == 1412) catch @panic("test failure");
10107 expect(v[11] == 1413) catch @panic("test failure");
10108 expect(v[12] == 1414) catch @panic("test failure");
10109 expect(v[13] == 1415) catch @panic("test failure");
10110 expect(v[14] == 1416) catch @panic("test failure");
10111 expect(v[15] == 1417) catch @panic("test failure");
10112 expect(v[16] == 1418) catch @panic("test failure");
10113 expect(v[17] == 1419) catch @panic("test failure");
10114 expect(v[18] == 1420) catch @panic("test failure");
10115 expect(v[19] == 1421) catch @panic("test failure");
10116 expect(v[20] == 1422) catch @panic("test failure");
10117 expect(v[21] == 1423) catch @panic("test failure");
10118 expect(v[22] == 1424) catch @panic("test failure");
10119 expect(v[23] == 1425) catch @panic("test failure");
10120 expect(v[24] == 1426) catch @panic("test failure");
10121 expect(v[25] == 1427) catch @panic("test failure");
10122 expect(v[26] == 1428) catch @panic("test failure");
10123 expect(v[27] == 1429) catch @panic("test failure");
10124 expect(v[28] == 1430) catch @panic("test failure");
10125 expect(v[29] == 1431) catch @panic("test failure");
10126 expect(v[30] == 1432) catch @panic("test failure");
10127 expect(v[31] == 1433) catch @panic("test failure");
10128 expect(v[32] == 1434) catch @panic("test failure");
10129 expect(v[33] == 1435) catch @panic("test failure");
10130 expect(v[34] == 1436) catch @panic("test failure");
10131 expect(v[35] == 1437) catch @panic("test failure");
10132 expect(v[36] == 1438) catch @panic("test failure");
10133 expect(v[37] == 1439) catch @panic("test failure");
10134 expect(v[38] == 1440) catch @panic("test failure");
10135 expect(v[39] == 1441) catch @panic("test failure");
10136 expect(v[40] == 1442) catch @panic("test failure");
10137 expect(v[41] == 1443) catch @panic("test failure");
10138 expect(v[42] == 1444) catch @panic("test failure");
10139 expect(v[43] == 1445) catch @panic("test failure");
10140 expect(v[44] == 1446) catch @panic("test failure");
10141 expect(v[45] == 1447) catch @panic("test failure");
10142 expect(v[46] == 1448) catch @panic("test failure");
10143 expect(v[47] == 1449) catch @panic("test failure");
10144 expect(v[48] == 1450) catch @panic("test failure");
10145 expect(v[49] == 1451) catch @panic("test failure");
10146 expect(v[50] == 1452) catch @panic("test failure");
10147 expect(v[51] == 1453) catch @panic("test failure");
10148 expect(v[52] == 1454) catch @panic("test failure");
10149 expect(v[53] == 1455) catch @panic("test failure");
10150 expect(v[54] == 1456) catch @panic("test failure");
10151 expect(v[55] == 1457) catch @panic("test failure");
10152 expect(v[56] == 1458) catch @panic("test failure");
10153 expect(v[57] == 1459) catch @panic("test failure");
10154 expect(v[58] == 1460) catch @panic("test failure");
10155 expect(v[59] == 1461) catch @panic("test failure");
10156 expect(v[60] == 1462) catch @panic("test failure");
10157 expect(v[61] == 1463) catch @panic("test failure");
10158 expect(v[62] == 1464) catch @panic("test failure");
10159 expect(v[63] == 1465) catch @panic("test failure");
10160 expect(v[64] == 1466) catch @panic("test failure");
10161 expect(v[65] == 1467) catch @panic("test failure");
10162 expect(v[66] == 1468) catch @panic("test failure");
10163 expect(v[67] == 1469) catch @panic("test failure");
10164 expect(v[68] == 1470) catch @panic("test failure");
10165 expect(v[69] == 1471) catch @panic("test failure");
10166 expect(v[70] == 1472) catch @panic("test failure");
10167 expect(v[71] == 1473) catch @panic("test failure");
10168 expect(v[72] == 1474) catch @panic("test failure");
10169 expect(v[73] == 1475) catch @panic("test failure");
10170 expect(v[74] == 1476) catch @panic("test failure");
10171 expect(v[75] == 1477) catch @panic("test failure");
10172 expect(v[76] == 1478) catch @panic("test failure");
10173 expect(v[77] == 1479) catch @panic("test failure");
10174 expect(v[78] == 1480) catch @panic("test failure");
10175 expect(v[79] == 1481) catch @panic("test failure");
10176 expect(v[80] == 1482) catch @panic("test failure");
10177 expect(v[81] == 1483) catch @panic("test failure");
10178 expect(v[82] == 1484) catch @panic("test failure");
10179 expect(v[83] == 1485) catch @panic("test failure");
10180 expect(v[84] == 1486) catch @panic("test failure");
10181 expect(v[85] == 1487) catch @panic("test failure");
10182 expect(v[86] == 1488) catch @panic("test failure");
10183 expect(v[87] == 1489) catch @panic("test failure");
10184 expect(v[88] == 1490) catch @panic("test failure");
10185 expect(v[89] == 1491) catch @panic("test failure");
10186 expect(v[90] == 1492) catch @panic("test failure");
10187 expect(v[91] == 1493) catch @panic("test failure");
10188 expect(v[92] == 1494) catch @panic("test failure");
10189 expect(v[93] == 1495) catch @panic("test failure");
10190 expect(v[94] == 1496) catch @panic("test failure");
10191 expect(v[95] == 1497) catch @panic("test failure");
10192 expect(v[96] == 1498) catch @panic("test failure");
10193 expect(v[97] == 1499) catch @panic("test failure");
10194 expect(v[98] == 1500) catch @panic("test failure");
10195 expect(v[99] == 1501) catch @panic("test failure");
10196 expect(v[100] == 1502) catch @panic("test failure");
10197 expect(v[101] == 1503) catch @panic("test failure");
10198 expect(v[102] == 1504) catch @panic("test failure");
10199 expect(v[103] == 1505) catch @panic("test failure");
10200 expect(v[104] == 1506) catch @panic("test failure");
10201 expect(v[105] == 1507) catch @panic("test failure");
10202 expect(v[106] == 1508) catch @panic("test failure");
10203 expect(v[107] == 1509) catch @panic("test failure");
10204 expect(v[108] == 1510) catch @panic("test failure");
10205 expect(v[109] == 1511) catch @panic("test failure");
10206 expect(v[110] == 1512) catch @panic("test failure");
10207 expect(v[111] == 1513) catch @panic("test failure");
10208 expect(v[112] == 1514) catch @panic("test failure");
10209 expect(v[113] == 1515) catch @panic("test failure");
10210 expect(v[114] == 1516) catch @panic("test failure");
10211 expect(v[115] == 1517) catch @panic("test failure");
10212 expect(v[116] == 1518) catch @panic("test failure");
10213 expect(v[117] == 1519) catch @panic("test failure");
10214 expect(v[118] == 1520) catch @panic("test failure");
10215 expect(v[119] == 1521) catch @panic("test failure");
10216 expect(v[120] == 1522) catch @panic("test failure");
10217 expect(v[121] == 1523) catch @panic("test failure");
10218 expect(v[122] == 1524) catch @panic("test failure");
10219 expect(v[123] == 1525) catch @panic("test failure");
10220 expect(v[124] == 1526) catch @panic("test failure");
10221 expect(v[125] == 1527) catch @panic("test failure");
10222 expect(v[126] == 1528) catch @panic("test failure");
10223 expect(v[127] == 1529) catch @panic("test failure");
10224 expect(i == 128) catch @panic("test failure");
10225}
10226
10227extern fn c_ret_vector_128_u16() @Vector(128, u16);
10228extern fn c_vector_128_u16(@Vector(128, u16), usize) void;
10229extern fn c_test_vector_128_u16() void;
10230
10231test "@Vector(128, u16)" {
10232 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
10233 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
10234 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
10235 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
10236
10237 const v = c_ret_vector_128_u16();
10238 try expect(v[0] == 1530);
10239 try expect(v[1] == 1531);
10240 try expect(v[2] == 1532);
10241 try expect(v[3] == 1533);
10242 try expect(v[4] == 1534);
10243 try expect(v[5] == 1535);
10244 try expect(v[6] == 1536);
10245 try expect(v[7] == 1537);
10246 try expect(v[8] == 1538);
10247 try expect(v[9] == 1539);
10248 try expect(v[10] == 1540);
10249 try expect(v[11] == 1541);
10250 try expect(v[12] == 1542);
10251 try expect(v[13] == 1543);
10252 try expect(v[14] == 1544);
10253 try expect(v[15] == 1545);
10254 try expect(v[16] == 1546);
10255 try expect(v[17] == 1547);
10256 try expect(v[18] == 1548);
10257 try expect(v[19] == 1549);
10258 try expect(v[20] == 1550);
10259 try expect(v[21] == 1551);
10260 try expect(v[22] == 1552);
10261 try expect(v[23] == 1553);
10262 try expect(v[24] == 1554);
10263 try expect(v[25] == 1555);
10264 try expect(v[26] == 1556);
10265 try expect(v[27] == 1557);
10266 try expect(v[28] == 1558);
10267 try expect(v[29] == 1559);
10268 try expect(v[30] == 1560);
10269 try expect(v[31] == 1561);
10270 try expect(v[32] == 1562);
10271 try expect(v[33] == 1563);
10272 try expect(v[34] == 1564);
10273 try expect(v[35] == 1565);
10274 try expect(v[36] == 1566);
10275 try expect(v[37] == 1567);
10276 try expect(v[38] == 1568);
10277 try expect(v[39] == 1569);
10278 try expect(v[40] == 1570);
10279 try expect(v[41] == 1571);
10280 try expect(v[42] == 1572);
10281 try expect(v[43] == 1573);
10282 try expect(v[44] == 1574);
10283 try expect(v[45] == 1575);
10284 try expect(v[46] == 1576);
10285 try expect(v[47] == 1577);
10286 try expect(v[48] == 1578);
10287 try expect(v[49] == 1579);
10288 try expect(v[50] == 1580);
10289 try expect(v[51] == 1581);
10290 try expect(v[52] == 1582);
10291 try expect(v[53] == 1583);
10292 try expect(v[54] == 1584);
10293 try expect(v[55] == 1585);
10294 try expect(v[56] == 1586);
10295 try expect(v[57] == 1587);
10296 try expect(v[58] == 1588);
10297 try expect(v[59] == 1589);
10298 try expect(v[60] == 1590);
10299 try expect(v[61] == 1591);
10300 try expect(v[62] == 1592);
10301 try expect(v[63] == 1593);
10302 try expect(v[64] == 1594);
10303 try expect(v[65] == 1595);
10304 try expect(v[66] == 1596);
10305 try expect(v[67] == 1597);
10306 try expect(v[68] == 1598);
10307 try expect(v[69] == 1599);
10308 try expect(v[70] == 1600);
10309 try expect(v[71] == 1601);
10310 try expect(v[72] == 1602);
10311 try expect(v[73] == 1603);
10312 try expect(v[74] == 1604);
10313 try expect(v[75] == 1605);
10314 try expect(v[76] == 1606);
10315 try expect(v[77] == 1607);
10316 try expect(v[78] == 1608);
10317 try expect(v[79] == 1609);
10318 try expect(v[80] == 1610);
10319 try expect(v[81] == 1611);
10320 try expect(v[82] == 1612);
10321 try expect(v[83] == 1613);
10322 try expect(v[84] == 1614);
10323 try expect(v[85] == 1615);
10324 try expect(v[86] == 1616);
10325 try expect(v[87] == 1617);
10326 try expect(v[88] == 1618);
10327 try expect(v[89] == 1619);
10328 try expect(v[90] == 1620);
10329 try expect(v[91] == 1621);
10330 try expect(v[92] == 1622);
10331 try expect(v[93] == 1623);
10332 try expect(v[94] == 1624);
10333 try expect(v[95] == 1625);
10334 try expect(v[96] == 1626);
10335 try expect(v[97] == 1627);
10336 try expect(v[98] == 1628);
10337 try expect(v[99] == 1629);
10338 try expect(v[100] == 1630);
10339 try expect(v[101] == 1631);
10340 try expect(v[102] == 1632);
10341 try expect(v[103] == 1633);
10342 try expect(v[104] == 1634);
10343 try expect(v[105] == 1635);
10344 try expect(v[106] == 1636);
10345 try expect(v[107] == 1637);
10346 try expect(v[108] == 1638);
10347 try expect(v[109] == 1639);
10348 try expect(v[110] == 1640);
10349 try expect(v[111] == 1641);
10350 try expect(v[112] == 1642);
10351 try expect(v[113] == 1643);
10352 try expect(v[114] == 1644);
10353 try expect(v[115] == 1645);
10354 try expect(v[116] == 1646);
10355 try expect(v[117] == 1647);
10356 try expect(v[118] == 1648);
10357 try expect(v[119] == 1649);
10358 try expect(v[120] == 1650);
10359 try expect(v[121] == 1651);
10360 try expect(v[122] == 1652);
10361 try expect(v[123] == 1653);
10362 try expect(v[124] == 1654);
10363 try expect(v[125] == 1655);
10364 try expect(v[126] == 1656);
10365 try expect(v[127] == 1657);
10366 c_vector_128_u16(.{
10367 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
10368 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
10369 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
10370 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
10371 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
10372 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
10373 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
10374 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
10375 }, 128);
10376 c_test_vector_128_u16();
10377}
10378
10379export fn zig_ret_vector_192_u16() @Vector(192, u16) {
10380 return .{
10381 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801,
10382 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817,
10383 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833,
10384 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849,
10385 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865,
10386 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881,
10387 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897,
10388 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
10389 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929,
10390 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945,
10391 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961,
10392 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977,
10393 };
10394}
10395export fn zig_vector_192_u16(v: @Vector(192, u16), i: usize) void {
10396 expect(v[0] == 1978) catch @panic("test failure");
10397 expect(v[1] == 1979) catch @panic("test failure");
10398 expect(v[2] == 1980) catch @panic("test failure");
10399 expect(v[3] == 1981) catch @panic("test failure");
10400 expect(v[4] == 1982) catch @panic("test failure");
10401 expect(v[5] == 1983) catch @panic("test failure");
10402 expect(v[6] == 1984) catch @panic("test failure");
10403 expect(v[7] == 1985) catch @panic("test failure");
10404 expect(v[8] == 1986) catch @panic("test failure");
10405 expect(v[9] == 1987) catch @panic("test failure");
10406 expect(v[10] == 1988) catch @panic("test failure");
10407 expect(v[11] == 1989) catch @panic("test failure");
10408 expect(v[12] == 1990) catch @panic("test failure");
10409 expect(v[13] == 1991) catch @panic("test failure");
10410 expect(v[14] == 1992) catch @panic("test failure");
10411 expect(v[15] == 1993) catch @panic("test failure");
10412 expect(v[16] == 1994) catch @panic("test failure");
10413 expect(v[17] == 1995) catch @panic("test failure");
10414 expect(v[18] == 1996) catch @panic("test failure");
10415 expect(v[19] == 1997) catch @panic("test failure");
10416 expect(v[20] == 1998) catch @panic("test failure");
10417 expect(v[21] == 1999) catch @panic("test failure");
10418 expect(v[22] == 2000) catch @panic("test failure");
10419 expect(v[23] == 2001) catch @panic("test failure");
10420 expect(v[24] == 2002) catch @panic("test failure");
10421 expect(v[25] == 2003) catch @panic("test failure");
10422 expect(v[26] == 2004) catch @panic("test failure");
10423 expect(v[27] == 2005) catch @panic("test failure");
10424 expect(v[28] == 2006) catch @panic("test failure");
10425 expect(v[29] == 2007) catch @panic("test failure");
10426 expect(v[30] == 2008) catch @panic("test failure");
10427 expect(v[31] == 2009) catch @panic("test failure");
10428 expect(v[32] == 2010) catch @panic("test failure");
10429 expect(v[33] == 2011) catch @panic("test failure");
10430 expect(v[34] == 2012) catch @panic("test failure");
10431 expect(v[35] == 2013) catch @panic("test failure");
10432 expect(v[36] == 2014) catch @panic("test failure");
10433 expect(v[37] == 2015) catch @panic("test failure");
10434 expect(v[38] == 2016) catch @panic("test failure");
10435 expect(v[39] == 2017) catch @panic("test failure");
10436 expect(v[40] == 2018) catch @panic("test failure");
10437 expect(v[41] == 2019) catch @panic("test failure");
10438 expect(v[42] == 2020) catch @panic("test failure");
10439 expect(v[43] == 2021) catch @panic("test failure");
10440 expect(v[44] == 2022) catch @panic("test failure");
10441 expect(v[45] == 2023) catch @panic("test failure");
10442 expect(v[46] == 2024) catch @panic("test failure");
10443 expect(v[47] == 2025) catch @panic("test failure");
10444 expect(v[48] == 2026) catch @panic("test failure");
10445 expect(v[49] == 2027) catch @panic("test failure");
10446 expect(v[50] == 2028) catch @panic("test failure");
10447 expect(v[51] == 2029) catch @panic("test failure");
10448 expect(v[52] == 2030) catch @panic("test failure");
10449 expect(v[53] == 2031) catch @panic("test failure");
10450 expect(v[54] == 2032) catch @panic("test failure");
10451 expect(v[55] == 2033) catch @panic("test failure");
10452 expect(v[56] == 2034) catch @panic("test failure");
10453 expect(v[57] == 2035) catch @panic("test failure");
10454 expect(v[58] == 2036) catch @panic("test failure");
10455 expect(v[59] == 2037) catch @panic("test failure");
10456 expect(v[60] == 2038) catch @panic("test failure");
10457 expect(v[61] == 2039) catch @panic("test failure");
10458 expect(v[62] == 2040) catch @panic("test failure");
10459 expect(v[63] == 2041) catch @panic("test failure");
10460 expect(v[64] == 2042) catch @panic("test failure");
10461 expect(v[65] == 2043) catch @panic("test failure");
10462 expect(v[66] == 2044) catch @panic("test failure");
10463 expect(v[67] == 2045) catch @panic("test failure");
10464 expect(v[68] == 2046) catch @panic("test failure");
10465 expect(v[69] == 2047) catch @panic("test failure");
10466 expect(v[70] == 2048) catch @panic("test failure");
10467 expect(v[71] == 2049) catch @panic("test failure");
10468 expect(v[72] == 2050) catch @panic("test failure");
10469 expect(v[73] == 2051) catch @panic("test failure");
10470 expect(v[74] == 2052) catch @panic("test failure");
10471 expect(v[75] == 2053) catch @panic("test failure");
10472 expect(v[76] == 2054) catch @panic("test failure");
10473 expect(v[77] == 2055) catch @panic("test failure");
10474 expect(v[78] == 2056) catch @panic("test failure");
10475 expect(v[79] == 2057) catch @panic("test failure");
10476 expect(v[80] == 2058) catch @panic("test failure");
10477 expect(v[81] == 2059) catch @panic("test failure");
10478 expect(v[82] == 2060) catch @panic("test failure");
10479 expect(v[83] == 2061) catch @panic("test failure");
10480 expect(v[84] == 2062) catch @panic("test failure");
10481 expect(v[85] == 2063) catch @panic("test failure");
10482 expect(v[86] == 2064) catch @panic("test failure");
10483 expect(v[87] == 2065) catch @panic("test failure");
10484 expect(v[88] == 2066) catch @panic("test failure");
10485 expect(v[89] == 2067) catch @panic("test failure");
10486 expect(v[90] == 2068) catch @panic("test failure");
10487 expect(v[91] == 2069) catch @panic("test failure");
10488 expect(v[92] == 2070) catch @panic("test failure");
10489 expect(v[93] == 2071) catch @panic("test failure");
10490 expect(v[94] == 2072) catch @panic("test failure");
10491 expect(v[95] == 2073) catch @panic("test failure");
10492 expect(v[96] == 2074) catch @panic("test failure");
10493 expect(v[97] == 2075) catch @panic("test failure");
10494 expect(v[98] == 2076) catch @panic("test failure");
10495 expect(v[99] == 2077) catch @panic("test failure");
10496 expect(v[100] == 2078) catch @panic("test failure");
10497 expect(v[101] == 2079) catch @panic("test failure");
10498 expect(v[102] == 2080) catch @panic("test failure");
10499 expect(v[103] == 2081) catch @panic("test failure");
10500 expect(v[104] == 2082) catch @panic("test failure");
10501 expect(v[105] == 2083) catch @panic("test failure");
10502 expect(v[106] == 2084) catch @panic("test failure");
10503 expect(v[107] == 2085) catch @panic("test failure");
10504 expect(v[108] == 2086) catch @panic("test failure");
10505 expect(v[109] == 2087) catch @panic("test failure");
10506 expect(v[110] == 2088) catch @panic("test failure");
10507 expect(v[111] == 2089) catch @panic("test failure");
10508 expect(v[112] == 2090) catch @panic("test failure");
10509 expect(v[113] == 2091) catch @panic("test failure");
10510 expect(v[114] == 2092) catch @panic("test failure");
10511 expect(v[115] == 2093) catch @panic("test failure");
10512 expect(v[116] == 2094) catch @panic("test failure");
10513 expect(v[117] == 2095) catch @panic("test failure");
10514 expect(v[118] == 2096) catch @panic("test failure");
10515 expect(v[119] == 2097) catch @panic("test failure");
10516 expect(v[120] == 2098) catch @panic("test failure");
10517 expect(v[121] == 2099) catch @panic("test failure");
10518 expect(v[122] == 2100) catch @panic("test failure");
10519 expect(v[123] == 2101) catch @panic("test failure");
10520 expect(v[124] == 2102) catch @panic("test failure");
10521 expect(v[125] == 2103) catch @panic("test failure");
10522 expect(v[126] == 2104) catch @panic("test failure");
10523 expect(v[127] == 2105) catch @panic("test failure");
10524 expect(v[128] == 2106) catch @panic("test failure");
10525 expect(v[129] == 2107) catch @panic("test failure");
10526 expect(v[130] == 2108) catch @panic("test failure");
10527 expect(v[131] == 2109) catch @panic("test failure");
10528 expect(v[132] == 2110) catch @panic("test failure");
10529 expect(v[133] == 2111) catch @panic("test failure");
10530 expect(v[134] == 2112) catch @panic("test failure");
10531 expect(v[135] == 2113) catch @panic("test failure");
10532 expect(v[136] == 2114) catch @panic("test failure");
10533 expect(v[137] == 2115) catch @panic("test failure");
10534 expect(v[138] == 2116) catch @panic("test failure");
10535 expect(v[139] == 2117) catch @panic("test failure");
10536 expect(v[140] == 2118) catch @panic("test failure");
10537 expect(v[141] == 2119) catch @panic("test failure");
10538 expect(v[142] == 2120) catch @panic("test failure");
10539 expect(v[143] == 2121) catch @panic("test failure");
10540 expect(v[144] == 2122) catch @panic("test failure");
10541 expect(v[145] == 2123) catch @panic("test failure");
10542 expect(v[146] == 2124) catch @panic("test failure");
10543 expect(v[147] == 2125) catch @panic("test failure");
10544 expect(v[148] == 2126) catch @panic("test failure");
10545 expect(v[149] == 2127) catch @panic("test failure");
10546 expect(v[150] == 2128) catch @panic("test failure");
10547 expect(v[151] == 2129) catch @panic("test failure");
10548 expect(v[152] == 2130) catch @panic("test failure");
10549 expect(v[153] == 2131) catch @panic("test failure");
10550 expect(v[154] == 2132) catch @panic("test failure");
10551 expect(v[155] == 2133) catch @panic("test failure");
10552 expect(v[156] == 2134) catch @panic("test failure");
10553 expect(v[157] == 2135) catch @panic("test failure");
10554 expect(v[158] == 2136) catch @panic("test failure");
10555 expect(v[159] == 2137) catch @panic("test failure");
10556 expect(v[160] == 2138) catch @panic("test failure");
10557 expect(v[161] == 2139) catch @panic("test failure");
10558 expect(v[162] == 2140) catch @panic("test failure");
10559 expect(v[163] == 2141) catch @panic("test failure");
10560 expect(v[164] == 2142) catch @panic("test failure");
10561 expect(v[165] == 2143) catch @panic("test failure");
10562 expect(v[166] == 2144) catch @panic("test failure");
10563 expect(v[167] == 2145) catch @panic("test failure");
10564 expect(v[168] == 2146) catch @panic("test failure");
10565 expect(v[169] == 2147) catch @panic("test failure");
10566 expect(v[170] == 2148) catch @panic("test failure");
10567 expect(v[171] == 2149) catch @panic("test failure");
10568 expect(v[172] == 2150) catch @panic("test failure");
10569 expect(v[173] == 2151) catch @panic("test failure");
10570 expect(v[174] == 2152) catch @panic("test failure");
10571 expect(v[175] == 2153) catch @panic("test failure");
10572 expect(v[176] == 2154) catch @panic("test failure");
10573 expect(v[177] == 2155) catch @panic("test failure");
10574 expect(v[178] == 2156) catch @panic("test failure");
10575 expect(v[179] == 2157) catch @panic("test failure");
10576 expect(v[180] == 2158) catch @panic("test failure");
10577 expect(v[181] == 2159) catch @panic("test failure");
10578 expect(v[182] == 2160) catch @panic("test failure");
10579 expect(v[183] == 2161) catch @panic("test failure");
10580 expect(v[184] == 2162) catch @panic("test failure");
10581 expect(v[185] == 2163) catch @panic("test failure");
10582 expect(v[186] == 2164) catch @panic("test failure");
10583 expect(v[187] == 2165) catch @panic("test failure");
10584 expect(v[188] == 2166) catch @panic("test failure");
10585 expect(v[189] == 2167) catch @panic("test failure");
10586 expect(v[190] == 2168) catch @panic("test failure");
10587 expect(v[191] == 2169) catch @panic("test failure");
10588 expect(i == 192) catch @panic("test failure");
10589}
10590
10591extern fn c_ret_vector_192_u16() @Vector(192, u16);
10592extern fn c_vector_192_u16(@Vector(192, u16), usize) void;
10593extern fn c_test_vector_192_u16() void;
10594
10595test "@Vector(192, u16)" {
10596 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
10597 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
10598 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
10599 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
10600
10601 const v = c_ret_vector_192_u16();
10602 try expect(v[0] == 2170);
10603 try expect(v[1] == 2171);
10604 try expect(v[2] == 2172);
10605 try expect(v[3] == 2173);
10606 try expect(v[4] == 2174);
10607 try expect(v[5] == 2175);
10608 try expect(v[6] == 2176);
10609 try expect(v[7] == 2177);
10610 try expect(v[8] == 2178);
10611 try expect(v[9] == 2179);
10612 try expect(v[10] == 2180);
10613 try expect(v[11] == 2181);
10614 try expect(v[12] == 2182);
10615 try expect(v[13] == 2183);
10616 try expect(v[14] == 2184);
10617 try expect(v[15] == 2185);
10618 try expect(v[16] == 2186);
10619 try expect(v[17] == 2187);
10620 try expect(v[18] == 2188);
10621 try expect(v[19] == 2189);
10622 try expect(v[20] == 2190);
10623 try expect(v[21] == 2191);
10624 try expect(v[22] == 2192);
10625 try expect(v[23] == 2193);
10626 try expect(v[24] == 2194);
10627 try expect(v[25] == 2195);
10628 try expect(v[26] == 2196);
10629 try expect(v[27] == 2197);
10630 try expect(v[28] == 2198);
10631 try expect(v[29] == 2199);
10632 try expect(v[30] == 2200);
10633 try expect(v[31] == 2201);
10634 try expect(v[32] == 2202);
10635 try expect(v[33] == 2203);
10636 try expect(v[34] == 2204);
10637 try expect(v[35] == 2205);
10638 try expect(v[36] == 2206);
10639 try expect(v[37] == 2207);
10640 try expect(v[38] == 2208);
10641 try expect(v[39] == 2209);
10642 try expect(v[40] == 2210);
10643 try expect(v[41] == 2211);
10644 try expect(v[42] == 2212);
10645 try expect(v[43] == 2213);
10646 try expect(v[44] == 2214);
10647 try expect(v[45] == 2215);
10648 try expect(v[46] == 2216);
10649 try expect(v[47] == 2217);
10650 try expect(v[48] == 2218);
10651 try expect(v[49] == 2219);
10652 try expect(v[50] == 2220);
10653 try expect(v[51] == 2221);
10654 try expect(v[52] == 2222);
10655 try expect(v[53] == 2223);
10656 try expect(v[54] == 2224);
10657 try expect(v[55] == 2225);
10658 try expect(v[56] == 2226);
10659 try expect(v[57] == 2227);
10660 try expect(v[58] == 2228);
10661 try expect(v[59] == 2229);
10662 try expect(v[60] == 2230);
10663 try expect(v[61] == 2231);
10664 try expect(v[62] == 2232);
10665 try expect(v[63] == 2233);
10666 try expect(v[64] == 2234);
10667 try expect(v[65] == 2235);
10668 try expect(v[66] == 2236);
10669 try expect(v[67] == 2237);
10670 try expect(v[68] == 2238);
10671 try expect(v[69] == 2239);
10672 try expect(v[70] == 2240);
10673 try expect(v[71] == 2241);
10674 try expect(v[72] == 2242);
10675 try expect(v[73] == 2243);
10676 try expect(v[74] == 2244);
10677 try expect(v[75] == 2245);
10678 try expect(v[76] == 2246);
10679 try expect(v[77] == 2247);
10680 try expect(v[78] == 2248);
10681 try expect(v[79] == 2249);
10682 try expect(v[80] == 2250);
10683 try expect(v[81] == 2251);
10684 try expect(v[82] == 2252);
10685 try expect(v[83] == 2253);
10686 try expect(v[84] == 2254);
10687 try expect(v[85] == 2255);
10688 try expect(v[86] == 2256);
10689 try expect(v[87] == 2257);
10690 try expect(v[88] == 2258);
10691 try expect(v[89] == 2259);
10692 try expect(v[90] == 2260);
10693 try expect(v[91] == 2261);
10694 try expect(v[92] == 2262);
10695 try expect(v[93] == 2263);
10696 try expect(v[94] == 2264);
10697 try expect(v[95] == 2265);
10698 try expect(v[96] == 2266);
10699 try expect(v[97] == 2267);
10700 try expect(v[98] == 2268);
10701 try expect(v[99] == 2269);
10702 try expect(v[100] == 2270);
10703 try expect(v[101] == 2271);
10704 try expect(v[102] == 2272);
10705 try expect(v[103] == 2273);
10706 try expect(v[104] == 2274);
10707 try expect(v[105] == 2275);
10708 try expect(v[106] == 2276);
10709 try expect(v[107] == 2277);
10710 try expect(v[108] == 2278);
10711 try expect(v[109] == 2279);
10712 try expect(v[110] == 2280);
10713 try expect(v[111] == 2281);
10714 try expect(v[112] == 2282);
10715 try expect(v[113] == 2283);
10716 try expect(v[114] == 2284);
10717 try expect(v[115] == 2285);
10718 try expect(v[116] == 2286);
10719 try expect(v[117] == 2287);
10720 try expect(v[118] == 2288);
10721 try expect(v[119] == 2289);
10722 try expect(v[120] == 2290);
10723 try expect(v[121] == 2291);
10724 try expect(v[122] == 2292);
10725 try expect(v[123] == 2293);
10726 try expect(v[124] == 2294);
10727 try expect(v[125] == 2295);
10728 try expect(v[126] == 2296);
10729 try expect(v[127] == 2297);
10730 try expect(v[128] == 2298);
10731 try expect(v[129] == 2299);
10732 try expect(v[130] == 2300);
10733 try expect(v[131] == 2301);
10734 try expect(v[132] == 2302);
10735 try expect(v[133] == 2303);
10736 try expect(v[134] == 2304);
10737 try expect(v[135] == 2305);
10738 try expect(v[136] == 2306);
10739 try expect(v[137] == 2307);
10740 try expect(v[138] == 2308);
10741 try expect(v[139] == 2309);
10742 try expect(v[140] == 2310);
10743 try expect(v[141] == 2311);
10744 try expect(v[142] == 2312);
10745 try expect(v[143] == 2313);
10746 try expect(v[144] == 2314);
10747 try expect(v[145] == 2315);
10748 try expect(v[146] == 2316);
10749 try expect(v[147] == 2317);
10750 try expect(v[148] == 2318);
10751 try expect(v[149] == 2319);
10752 try expect(v[150] == 2320);
10753 try expect(v[151] == 2321);
10754 try expect(v[152] == 2322);
10755 try expect(v[153] == 2323);
10756 try expect(v[154] == 2324);
10757 try expect(v[155] == 2325);
10758 try expect(v[156] == 2326);
10759 try expect(v[157] == 2327);
10760 try expect(v[158] == 2328);
10761 try expect(v[159] == 2329);
10762 try expect(v[160] == 2330);
10763 try expect(v[161] == 2331);
10764 try expect(v[162] == 2332);
10765 try expect(v[163] == 2333);
10766 try expect(v[164] == 2334);
10767 try expect(v[165] == 2335);
10768 try expect(v[166] == 2336);
10769 try expect(v[167] == 2337);
10770 try expect(v[168] == 2338);
10771 try expect(v[169] == 2339);
10772 try expect(v[170] == 2340);
10773 try expect(v[171] == 2341);
10774 try expect(v[172] == 2342);
10775 try expect(v[173] == 2343);
10776 try expect(v[174] == 2344);
10777 try expect(v[175] == 2345);
10778 try expect(v[176] == 2346);
10779 try expect(v[177] == 2347);
10780 try expect(v[178] == 2348);
10781 try expect(v[179] == 2349);
10782 try expect(v[180] == 2350);
10783 try expect(v[181] == 2351);
10784 try expect(v[182] == 2352);
10785 try expect(v[183] == 2353);
10786 try expect(v[184] == 2354);
10787 try expect(v[185] == 2355);
10788 try expect(v[186] == 2356);
10789 try expect(v[187] == 2357);
10790 try expect(v[188] == 2358);
10791 try expect(v[189] == 2359);
10792 try expect(v[190] == 2360);
10793 try expect(v[191] == 2361);
10794 c_vector_192_u16(.{
10795 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377,
10796 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393,
10797 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409,
10798 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425,
10799 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441,
10800 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457,
10801 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473,
10802 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489,
10803 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505,
10804 2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521,
10805 2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537,
10806 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553,
10807 }, 192);
10808 c_test_vector_192_u16();
10809}
10810
10811export fn zig_ret_vector_256_u16() @Vector(256, u16) {
10812 return .{
10813 2554, 2555, 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569,
10814 2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583, 2584, 2585,
10815 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601,
10816 2602, 2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617,
10817 2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633,
10818 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649,
10819 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665,
10820 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, 2679, 2680, 2681,
10821 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697,
10822 2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713,
10823 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729,
10824 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745,
10825 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761,
10826 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777,
10827 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793,
10828 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809,
10829 };
10830}
10831export fn zig_vector_256_u16(v: @Vector(256, u16), i: usize) void {
10832 expect(v[0] == 2810) catch @panic("test failure");
10833 expect(v[1] == 2811) catch @panic("test failure");
10834 expect(v[2] == 2812) catch @panic("test failure");
10835 expect(v[3] == 2813) catch @panic("test failure");
10836 expect(v[4] == 2814) catch @panic("test failure");
10837 expect(v[5] == 2815) catch @panic("test failure");
10838 expect(v[6] == 2816) catch @panic("test failure");
10839 expect(v[7] == 2817) catch @panic("test failure");
10840 expect(v[8] == 2818) catch @panic("test failure");
10841 expect(v[9] == 2819) catch @panic("test failure");
10842 expect(v[10] == 2820) catch @panic("test failure");
10843 expect(v[11] == 2821) catch @panic("test failure");
10844 expect(v[12] == 2822) catch @panic("test failure");
10845 expect(v[13] == 2823) catch @panic("test failure");
10846 expect(v[14] == 2824) catch @panic("test failure");
10847 expect(v[15] == 2825) catch @panic("test failure");
10848 expect(v[16] == 2826) catch @panic("test failure");
10849 expect(v[17] == 2827) catch @panic("test failure");
10850 expect(v[18] == 2828) catch @panic("test failure");
10851 expect(v[19] == 2829) catch @panic("test failure");
10852 expect(v[20] == 2830) catch @panic("test failure");
10853 expect(v[21] == 2831) catch @panic("test failure");
10854 expect(v[22] == 2832) catch @panic("test failure");
10855 expect(v[23] == 2833) catch @panic("test failure");
10856 expect(v[24] == 2834) catch @panic("test failure");
10857 expect(v[25] == 2835) catch @panic("test failure");
10858 expect(v[26] == 2836) catch @panic("test failure");
10859 expect(v[27] == 2837) catch @panic("test failure");
10860 expect(v[28] == 2838) catch @panic("test failure");
10861 expect(v[29] == 2839) catch @panic("test failure");
10862 expect(v[30] == 2840) catch @panic("test failure");
10863 expect(v[31] == 2841) catch @panic("test failure");
10864 expect(v[32] == 2842) catch @panic("test failure");
10865 expect(v[33] == 2843) catch @panic("test failure");
10866 expect(v[34] == 2844) catch @panic("test failure");
10867 expect(v[35] == 2845) catch @panic("test failure");
10868 expect(v[36] == 2846) catch @panic("test failure");
10869 expect(v[37] == 2847) catch @panic("test failure");
10870 expect(v[38] == 2848) catch @panic("test failure");
10871 expect(v[39] == 2849) catch @panic("test failure");
10872 expect(v[40] == 2850) catch @panic("test failure");
10873 expect(v[41] == 2851) catch @panic("test failure");
10874 expect(v[42] == 2852) catch @panic("test failure");
10875 expect(v[43] == 2853) catch @panic("test failure");
10876 expect(v[44] == 2854) catch @panic("test failure");
10877 expect(v[45] == 2855) catch @panic("test failure");
10878 expect(v[46] == 2856) catch @panic("test failure");
10879 expect(v[47] == 2857) catch @panic("test failure");
10880 expect(v[48] == 2858) catch @panic("test failure");
10881 expect(v[49] == 2859) catch @panic("test failure");
10882 expect(v[50] == 2860) catch @panic("test failure");
10883 expect(v[51] == 2861) catch @panic("test failure");
10884 expect(v[52] == 2862) catch @panic("test failure");
10885 expect(v[53] == 2863) catch @panic("test failure");
10886 expect(v[54] == 2864) catch @panic("test failure");
10887 expect(v[55] == 2865) catch @panic("test failure");
10888 expect(v[56] == 2866) catch @panic("test failure");
10889 expect(v[57] == 2867) catch @panic("test failure");
10890 expect(v[58] == 2868) catch @panic("test failure");
10891 expect(v[59] == 2869) catch @panic("test failure");
10892 expect(v[60] == 2870) catch @panic("test failure");
10893 expect(v[61] == 2871) catch @panic("test failure");
10894 expect(v[62] == 2872) catch @panic("test failure");
10895 expect(v[63] == 2873) catch @panic("test failure");
10896 expect(v[64] == 2874) catch @panic("test failure");
10897 expect(v[65] == 2875) catch @panic("test failure");
10898 expect(v[66] == 2876) catch @panic("test failure");
10899 expect(v[67] == 2877) catch @panic("test failure");
10900 expect(v[68] == 2878) catch @panic("test failure");
10901 expect(v[69] == 2879) catch @panic("test failure");
10902 expect(v[70] == 2880) catch @panic("test failure");
10903 expect(v[71] == 2881) catch @panic("test failure");
10904 expect(v[72] == 2882) catch @panic("test failure");
10905 expect(v[73] == 2883) catch @panic("test failure");
10906 expect(v[74] == 2884) catch @panic("test failure");
10907 expect(v[75] == 2885) catch @panic("test failure");
10908 expect(v[76] == 2886) catch @panic("test failure");
10909 expect(v[77] == 2887) catch @panic("test failure");
10910 expect(v[78] == 2888) catch @panic("test failure");
10911 expect(v[79] == 2889) catch @panic("test failure");
10912 expect(v[80] == 2890) catch @panic("test failure");
10913 expect(v[81] == 2891) catch @panic("test failure");
10914 expect(v[82] == 2892) catch @panic("test failure");
10915 expect(v[83] == 2893) catch @panic("test failure");
10916 expect(v[84] == 2894) catch @panic("test failure");
10917 expect(v[85] == 2895) catch @panic("test failure");
10918 expect(v[86] == 2896) catch @panic("test failure");
10919 expect(v[87] == 2897) catch @panic("test failure");
10920 expect(v[88] == 2898) catch @panic("test failure");
10921 expect(v[89] == 2899) catch @panic("test failure");
10922 expect(v[90] == 2900) catch @panic("test failure");
10923 expect(v[91] == 2901) catch @panic("test failure");
10924 expect(v[92] == 2902) catch @panic("test failure");
10925 expect(v[93] == 2903) catch @panic("test failure");
10926 expect(v[94] == 2904) catch @panic("test failure");
10927 expect(v[95] == 2905) catch @panic("test failure");
10928 expect(v[96] == 2906) catch @panic("test failure");
10929 expect(v[97] == 2907) catch @panic("test failure");
10930 expect(v[98] == 2908) catch @panic("test failure");
10931 expect(v[99] == 2909) catch @panic("test failure");
10932 expect(v[100] == 2910) catch @panic("test failure");
10933 expect(v[101] == 2911) catch @panic("test failure");
10934 expect(v[102] == 2912) catch @panic("test failure");
10935 expect(v[103] == 2913) catch @panic("test failure");
10936 expect(v[104] == 2914) catch @panic("test failure");
10937 expect(v[105] == 2915) catch @panic("test failure");
10938 expect(v[106] == 2916) catch @panic("test failure");
10939 expect(v[107] == 2917) catch @panic("test failure");
10940 expect(v[108] == 2918) catch @panic("test failure");
10941 expect(v[109] == 2919) catch @panic("test failure");
10942 expect(v[110] == 2920) catch @panic("test failure");
10943 expect(v[111] == 2921) catch @panic("test failure");
10944 expect(v[112] == 2922) catch @panic("test failure");
10945 expect(v[113] == 2923) catch @panic("test failure");
10946 expect(v[114] == 2924) catch @panic("test failure");
10947 expect(v[115] == 2925) catch @panic("test failure");
10948 expect(v[116] == 2926) catch @panic("test failure");
10949 expect(v[117] == 2927) catch @panic("test failure");
10950 expect(v[118] == 2928) catch @panic("test failure");
10951 expect(v[119] == 2929) catch @panic("test failure");
10952 expect(v[120] == 2930) catch @panic("test failure");
10953 expect(v[121] == 2931) catch @panic("test failure");
10954 expect(v[122] == 2932) catch @panic("test failure");
10955 expect(v[123] == 2933) catch @panic("test failure");
10956 expect(v[124] == 2934) catch @panic("test failure");
10957 expect(v[125] == 2935) catch @panic("test failure");
10958 expect(v[126] == 2936) catch @panic("test failure");
10959 expect(v[127] == 2937) catch @panic("test failure");
10960 expect(v[128] == 2938) catch @panic("test failure");
10961 expect(v[129] == 2939) catch @panic("test failure");
10962 expect(v[130] == 2940) catch @panic("test failure");
10963 expect(v[131] == 2941) catch @panic("test failure");
10964 expect(v[132] == 2942) catch @panic("test failure");
10965 expect(v[133] == 2943) catch @panic("test failure");
10966 expect(v[134] == 2944) catch @panic("test failure");
10967 expect(v[135] == 2945) catch @panic("test failure");
10968 expect(v[136] == 2946) catch @panic("test failure");
10969 expect(v[137] == 2947) catch @panic("test failure");
10970 expect(v[138] == 2948) catch @panic("test failure");
10971 expect(v[139] == 2949) catch @panic("test failure");
10972 expect(v[140] == 2950) catch @panic("test failure");
10973 expect(v[141] == 2951) catch @panic("test failure");
10974 expect(v[142] == 2952) catch @panic("test failure");
10975 expect(v[143] == 2953) catch @panic("test failure");
10976 expect(v[144] == 2954) catch @panic("test failure");
10977 expect(v[145] == 2955) catch @panic("test failure");
10978 expect(v[146] == 2956) catch @panic("test failure");
10979 expect(v[147] == 2957) catch @panic("test failure");
10980 expect(v[148] == 2958) catch @panic("test failure");
10981 expect(v[149] == 2959) catch @panic("test failure");
10982 expect(v[150] == 2960) catch @panic("test failure");
10983 expect(v[151] == 2961) catch @panic("test failure");
10984 expect(v[152] == 2962) catch @panic("test failure");
10985 expect(v[153] == 2963) catch @panic("test failure");
10986 expect(v[154] == 2964) catch @panic("test failure");
10987 expect(v[155] == 2965) catch @panic("test failure");
10988 expect(v[156] == 2966) catch @panic("test failure");
10989 expect(v[157] == 2967) catch @panic("test failure");
10990 expect(v[158] == 2968) catch @panic("test failure");
10991 expect(v[159] == 2969) catch @panic("test failure");
10992 expect(v[160] == 2970) catch @panic("test failure");
10993 expect(v[161] == 2971) catch @panic("test failure");
10994 expect(v[162] == 2972) catch @panic("test failure");
10995 expect(v[163] == 2973) catch @panic("test failure");
10996 expect(v[164] == 2974) catch @panic("test failure");
10997 expect(v[165] == 2975) catch @panic("test failure");
10998 expect(v[166] == 2976) catch @panic("test failure");
10999 expect(v[167] == 2977) catch @panic("test failure");
11000 expect(v[168] == 2978) catch @panic("test failure");
11001 expect(v[169] == 2979) catch @panic("test failure");
11002 expect(v[170] == 2980) catch @panic("test failure");
11003 expect(v[171] == 2981) catch @panic("test failure");
11004 expect(v[172] == 2982) catch @panic("test failure");
11005 expect(v[173] == 2983) catch @panic("test failure");
11006 expect(v[174] == 2984) catch @panic("test failure");
11007 expect(v[175] == 2985) catch @panic("test failure");
11008 expect(v[176] == 2986) catch @panic("test failure");
11009 expect(v[177] == 2987) catch @panic("test failure");
11010 expect(v[178] == 2988) catch @panic("test failure");
11011 expect(v[179] == 2989) catch @panic("test failure");
11012 expect(v[180] == 2990) catch @panic("test failure");
11013 expect(v[181] == 2991) catch @panic("test failure");
11014 expect(v[182] == 2992) catch @panic("test failure");
11015 expect(v[183] == 2993) catch @panic("test failure");
11016 expect(v[184] == 2994) catch @panic("test failure");
11017 expect(v[185] == 2995) catch @panic("test failure");
11018 expect(v[186] == 2996) catch @panic("test failure");
11019 expect(v[187] == 2997) catch @panic("test failure");
11020 expect(v[188] == 2998) catch @panic("test failure");
11021 expect(v[189] == 2999) catch @panic("test failure");
11022 expect(v[190] == 3000) catch @panic("test failure");
11023 expect(v[191] == 3001) catch @panic("test failure");
11024 expect(v[192] == 3002) catch @panic("test failure");
11025 expect(v[193] == 3003) catch @panic("test failure");
11026 expect(v[194] == 3004) catch @panic("test failure");
11027 expect(v[195] == 3005) catch @panic("test failure");
11028 expect(v[196] == 3006) catch @panic("test failure");
11029 expect(v[197] == 3007) catch @panic("test failure");
11030 expect(v[198] == 3008) catch @panic("test failure");
11031 expect(v[199] == 3009) catch @panic("test failure");
11032 expect(v[200] == 3010) catch @panic("test failure");
11033 expect(v[201] == 3011) catch @panic("test failure");
11034 expect(v[202] == 3012) catch @panic("test failure");
11035 expect(v[203] == 3013) catch @panic("test failure");
11036 expect(v[204] == 3014) catch @panic("test failure");
11037 expect(v[205] == 3015) catch @panic("test failure");
11038 expect(v[206] == 3016) catch @panic("test failure");
11039 expect(v[207] == 3017) catch @panic("test failure");
11040 expect(v[208] == 3018) catch @panic("test failure");
11041 expect(v[209] == 3019) catch @panic("test failure");
11042 expect(v[210] == 3020) catch @panic("test failure");
11043 expect(v[211] == 3021) catch @panic("test failure");
11044 expect(v[212] == 3022) catch @panic("test failure");
11045 expect(v[213] == 3023) catch @panic("test failure");
11046 expect(v[214] == 3024) catch @panic("test failure");
11047 expect(v[215] == 3025) catch @panic("test failure");
11048 expect(v[216] == 3026) catch @panic("test failure");
11049 expect(v[217] == 3027) catch @panic("test failure");
11050 expect(v[218] == 3028) catch @panic("test failure");
11051 expect(v[219] == 3029) catch @panic("test failure");
11052 expect(v[220] == 3030) catch @panic("test failure");
11053 expect(v[221] == 3031) catch @panic("test failure");
11054 expect(v[222] == 3032) catch @panic("test failure");
11055 expect(v[223] == 3033) catch @panic("test failure");
11056 expect(v[224] == 3034) catch @panic("test failure");
11057 expect(v[225] == 3035) catch @panic("test failure");
11058 expect(v[226] == 3036) catch @panic("test failure");
11059 expect(v[227] == 3037) catch @panic("test failure");
11060 expect(v[228] == 3038) catch @panic("test failure");
11061 expect(v[229] == 3039) catch @panic("test failure");
11062 expect(v[230] == 3040) catch @panic("test failure");
11063 expect(v[231] == 3041) catch @panic("test failure");
11064 expect(v[232] == 3042) catch @panic("test failure");
11065 expect(v[233] == 3043) catch @panic("test failure");
11066 expect(v[234] == 3044) catch @panic("test failure");
11067 expect(v[235] == 3045) catch @panic("test failure");
11068 expect(v[236] == 3046) catch @panic("test failure");
11069 expect(v[237] == 3047) catch @panic("test failure");
11070 expect(v[238] == 3048) catch @panic("test failure");
11071 expect(v[239] == 3049) catch @panic("test failure");
11072 expect(v[240] == 3050) catch @panic("test failure");
11073 expect(v[241] == 3051) catch @panic("test failure");
11074 expect(v[242] == 3052) catch @panic("test failure");
11075 expect(v[243] == 3053) catch @panic("test failure");
11076 expect(v[244] == 3054) catch @panic("test failure");
11077 expect(v[245] == 3055) catch @panic("test failure");
11078 expect(v[246] == 3056) catch @panic("test failure");
11079 expect(v[247] == 3057) catch @panic("test failure");
11080 expect(v[248] == 3058) catch @panic("test failure");
11081 expect(v[249] == 3059) catch @panic("test failure");
11082 expect(v[250] == 3060) catch @panic("test failure");
11083 expect(v[251] == 3061) catch @panic("test failure");
11084 expect(v[252] == 3062) catch @panic("test failure");
11085 expect(v[253] == 3063) catch @panic("test failure");
11086 expect(v[254] == 3064) catch @panic("test failure");
11087 expect(v[255] == 3065) catch @panic("test failure");
11088 expect(i == 256) catch @panic("test failure");
11089}
11090
11091extern fn c_ret_vector_256_u16() @Vector(256, u16);
11092extern fn c_vector_256_u16(@Vector(256, u16), usize) void;
11093extern fn c_test_vector_256_u16() void;
11094
11095test "@Vector(256, u16)" {
11096 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11097 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11098 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
11099 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11100
11101 const v = c_ret_vector_256_u16();
11102 try expect(v[0] == 3066);
11103 try expect(v[1] == 3067);
11104 try expect(v[2] == 3068);
11105 try expect(v[3] == 3069);
11106 try expect(v[4] == 3070);
11107 try expect(v[5] == 3071);
11108 try expect(v[6] == 3072);
11109 try expect(v[7] == 3073);
11110 try expect(v[8] == 3074);
11111 try expect(v[9] == 3075);
11112 try expect(v[10] == 3076);
11113 try expect(v[11] == 3077);
11114 try expect(v[12] == 3078);
11115 try expect(v[13] == 3079);
11116 try expect(v[14] == 3080);
11117 try expect(v[15] == 3081);
11118 try expect(v[16] == 3082);
11119 try expect(v[17] == 3083);
11120 try expect(v[18] == 3084);
11121 try expect(v[19] == 3085);
11122 try expect(v[20] == 3086);
11123 try expect(v[21] == 3087);
11124 try expect(v[22] == 3088);
11125 try expect(v[23] == 3089);
11126 try expect(v[24] == 3090);
11127 try expect(v[25] == 3091);
11128 try expect(v[26] == 3092);
11129 try expect(v[27] == 3093);
11130 try expect(v[28] == 3094);
11131 try expect(v[29] == 3095);
11132 try expect(v[30] == 3096);
11133 try expect(v[31] == 3097);
11134 try expect(v[32] == 3098);
11135 try expect(v[33] == 3099);
11136 try expect(v[34] == 3100);
11137 try expect(v[35] == 3101);
11138 try expect(v[36] == 3102);
11139 try expect(v[37] == 3103);
11140 try expect(v[38] == 3104);
11141 try expect(v[39] == 3105);
11142 try expect(v[40] == 3106);
11143 try expect(v[41] == 3107);
11144 try expect(v[42] == 3108);
11145 try expect(v[43] == 3109);
11146 try expect(v[44] == 3110);
11147 try expect(v[45] == 3111);
11148 try expect(v[46] == 3112);
11149 try expect(v[47] == 3113);
11150 try expect(v[48] == 3114);
11151 try expect(v[49] == 3115);
11152 try expect(v[50] == 3116);
11153 try expect(v[51] == 3117);
11154 try expect(v[52] == 3118);
11155 try expect(v[53] == 3119);
11156 try expect(v[54] == 3120);
11157 try expect(v[55] == 3121);
11158 try expect(v[56] == 3122);
11159 try expect(v[57] == 3123);
11160 try expect(v[58] == 3124);
11161 try expect(v[59] == 3125);
11162 try expect(v[60] == 3126);
11163 try expect(v[61] == 3127);
11164 try expect(v[62] == 3128);
11165 try expect(v[63] == 3129);
11166 try expect(v[64] == 3130);
11167 try expect(v[65] == 3131);
11168 try expect(v[66] == 3132);
11169 try expect(v[67] == 3133);
11170 try expect(v[68] == 3134);
11171 try expect(v[69] == 3135);
11172 try expect(v[70] == 3136);
11173 try expect(v[71] == 3137);
11174 try expect(v[72] == 3138);
11175 try expect(v[73] == 3139);
11176 try expect(v[74] == 3140);
11177 try expect(v[75] == 3141);
11178 try expect(v[76] == 3142);
11179 try expect(v[77] == 3143);
11180 try expect(v[78] == 3144);
11181 try expect(v[79] == 3145);
11182 try expect(v[80] == 3146);
11183 try expect(v[81] == 3147);
11184 try expect(v[82] == 3148);
11185 try expect(v[83] == 3149);
11186 try expect(v[84] == 3150);
11187 try expect(v[85] == 3151);
11188 try expect(v[86] == 3152);
11189 try expect(v[87] == 3153);
11190 try expect(v[88] == 3154);
11191 try expect(v[89] == 3155);
11192 try expect(v[90] == 3156);
11193 try expect(v[91] == 3157);
11194 try expect(v[92] == 3158);
11195 try expect(v[93] == 3159);
11196 try expect(v[94] == 3160);
11197 try expect(v[95] == 3161);
11198 try expect(v[96] == 3162);
11199 try expect(v[97] == 3163);
11200 try expect(v[98] == 3164);
11201 try expect(v[99] == 3165);
11202 try expect(v[100] == 3166);
11203 try expect(v[101] == 3167);
11204 try expect(v[102] == 3168);
11205 try expect(v[103] == 3169);
11206 try expect(v[104] == 3170);
11207 try expect(v[105] == 3171);
11208 try expect(v[106] == 3172);
11209 try expect(v[107] == 3173);
11210 try expect(v[108] == 3174);
11211 try expect(v[109] == 3175);
11212 try expect(v[110] == 3176);
11213 try expect(v[111] == 3177);
11214 try expect(v[112] == 3178);
11215 try expect(v[113] == 3179);
11216 try expect(v[114] == 3180);
11217 try expect(v[115] == 3181);
11218 try expect(v[116] == 3182);
11219 try expect(v[117] == 3183);
11220 try expect(v[118] == 3184);
11221 try expect(v[119] == 3185);
11222 try expect(v[120] == 3186);
11223 try expect(v[121] == 3187);
11224 try expect(v[122] == 3188);
11225 try expect(v[123] == 3189);
11226 try expect(v[124] == 3190);
11227 try expect(v[125] == 3191);
11228 try expect(v[126] == 3192);
11229 try expect(v[127] == 3193);
11230 try expect(v[128] == 3194);
11231 try expect(v[129] == 3195);
11232 try expect(v[130] == 3196);
11233 try expect(v[131] == 3197);
11234 try expect(v[132] == 3198);
11235 try expect(v[133] == 3199);
11236 try expect(v[134] == 3200);
11237 try expect(v[135] == 3201);
11238 try expect(v[136] == 3202);
11239 try expect(v[137] == 3203);
11240 try expect(v[138] == 3204);
11241 try expect(v[139] == 3205);
11242 try expect(v[140] == 3206);
11243 try expect(v[141] == 3207);
11244 try expect(v[142] == 3208);
11245 try expect(v[143] == 3209);
11246 try expect(v[144] == 3210);
11247 try expect(v[145] == 3211);
11248 try expect(v[146] == 3212);
11249 try expect(v[147] == 3213);
11250 try expect(v[148] == 3214);
11251 try expect(v[149] == 3215);
11252 try expect(v[150] == 3216);
11253 try expect(v[151] == 3217);
11254 try expect(v[152] == 3218);
11255 try expect(v[153] == 3219);
11256 try expect(v[154] == 3220);
11257 try expect(v[155] == 3221);
11258 try expect(v[156] == 3222);
11259 try expect(v[157] == 3223);
11260 try expect(v[158] == 3224);
11261 try expect(v[159] == 3225);
11262 try expect(v[160] == 3226);
11263 try expect(v[161] == 3227);
11264 try expect(v[162] == 3228);
11265 try expect(v[163] == 3229);
11266 try expect(v[164] == 3230);
11267 try expect(v[165] == 3231);
11268 try expect(v[166] == 3232);
11269 try expect(v[167] == 3233);
11270 try expect(v[168] == 3234);
11271 try expect(v[169] == 3235);
11272 try expect(v[170] == 3236);
11273 try expect(v[171] == 3237);
11274 try expect(v[172] == 3238);
11275 try expect(v[173] == 3239);
11276 try expect(v[174] == 3240);
11277 try expect(v[175] == 3241);
11278 try expect(v[176] == 3242);
11279 try expect(v[177] == 3243);
11280 try expect(v[178] == 3244);
11281 try expect(v[179] == 3245);
11282 try expect(v[180] == 3246);
11283 try expect(v[181] == 3247);
11284 try expect(v[182] == 3248);
11285 try expect(v[183] == 3249);
11286 try expect(v[184] == 3250);
11287 try expect(v[185] == 3251);
11288 try expect(v[186] == 3252);
11289 try expect(v[187] == 3253);
11290 try expect(v[188] == 3254);
11291 try expect(v[189] == 3255);
11292 try expect(v[190] == 3256);
11293 try expect(v[191] == 3257);
11294 try expect(v[192] == 3258);
11295 try expect(v[193] == 3259);
11296 try expect(v[194] == 3260);
11297 try expect(v[195] == 3261);
11298 try expect(v[196] == 3262);
11299 try expect(v[197] == 3263);
11300 try expect(v[198] == 3264);
11301 try expect(v[199] == 3265);
11302 try expect(v[200] == 3266);
11303 try expect(v[201] == 3267);
11304 try expect(v[202] == 3268);
11305 try expect(v[203] == 3269);
11306 try expect(v[204] == 3270);
11307 try expect(v[205] == 3271);
11308 try expect(v[206] == 3272);
11309 try expect(v[207] == 3273);
11310 try expect(v[208] == 3274);
11311 try expect(v[209] == 3275);
11312 try expect(v[210] == 3276);
11313 try expect(v[211] == 3277);
11314 try expect(v[212] == 3278);
11315 try expect(v[213] == 3279);
11316 try expect(v[214] == 3280);
11317 try expect(v[215] == 3281);
11318 try expect(v[216] == 3282);
11319 try expect(v[217] == 3283);
11320 try expect(v[218] == 3284);
11321 try expect(v[219] == 3285);
11322 try expect(v[220] == 3286);
11323 try expect(v[221] == 3287);
11324 try expect(v[222] == 3288);
11325 try expect(v[223] == 3289);
11326 try expect(v[224] == 3290);
11327 try expect(v[225] == 3291);
11328 try expect(v[226] == 3292);
11329 try expect(v[227] == 3293);
11330 try expect(v[228] == 3294);
11331 try expect(v[229] == 3295);
11332 try expect(v[230] == 3296);
11333 try expect(v[231] == 3297);
11334 try expect(v[232] == 3298);
11335 try expect(v[233] == 3299);
11336 try expect(v[234] == 3300);
11337 try expect(v[235] == 3301);
11338 try expect(v[236] == 3302);
11339 try expect(v[237] == 3303);
11340 try expect(v[238] == 3304);
11341 try expect(v[239] == 3305);
11342 try expect(v[240] == 3306);
11343 try expect(v[241] == 3307);
11344 try expect(v[242] == 3308);
11345 try expect(v[243] == 3309);
11346 try expect(v[244] == 3310);
11347 try expect(v[245] == 3311);
11348 try expect(v[246] == 3312);
11349 try expect(v[247] == 3313);
11350 try expect(v[248] == 3314);
11351 try expect(v[249] == 3315);
11352 try expect(v[250] == 3316);
11353 try expect(v[251] == 3317);
11354 try expect(v[252] == 3318);
11355 try expect(v[253] == 3319);
11356 try expect(v[254] == 3320);
11357 try expect(v[255] == 3321);
11358 c_vector_256_u16(.{
11359 3322, 3323, 3324, 3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336, 3337,
11360 3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348, 3349, 3350, 3351, 3352, 3353,
11361 3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369,
11362 3370, 3371, 3372, 3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385,
11363 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, 3401,
11364 3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417,
11365 3418, 3419, 3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433,
11366 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448, 3449,
11367 3450, 3451, 3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, 3461, 3462, 3463, 3464, 3465,
11368 3466, 3467, 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3481,
11369 3482, 3483, 3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, 3493, 3494, 3495, 3496, 3497,
11370 3498, 3499, 3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513,
11371 3514, 3515, 3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526, 3527, 3528, 3529,
11372 3530, 3531, 3532, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 3544, 3545,
11373 3546, 3547, 3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 3556, 3557, 3558, 3559, 3560, 3561,
11374 3562, 3563, 3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574, 3575, 3576, 3577,
11375 }, 256);
11376 c_test_vector_256_u16();
11377}
11378
11379export fn zig_ret_vector_1_u32() @Vector(1, u32) {
11380 return .{1};
11381}
11382export fn zig_vector_1_u32(v: @Vector(1, u32), i: usize) void {
11383 expect(v[0] == 2) catch @panic("test failure");
11384 expect(i == 1) catch @panic("test failure");
11385}
11386
11387extern fn c_ret_vector_1_u32() @Vector(1, u32);
11388extern fn c_vector_1_u32(@Vector(1, u32), usize) void;
11389extern fn c_test_vector_1_u32() void;
11390
11391test "@Vector(1, u32)" {
11392 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
11393 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
11394
11395 const v = c_ret_vector_1_u32();
11396 try expect(v[0] == 3);
11397 c_vector_1_u32(.{4}, 1);
11398 c_test_vector_1_u32();
11399}
11400
11401export fn zig_ret_vector_2_u32() @Vector(2, u32) {
11402 return .{ 5, 6 };
11403}
11404export fn zig_vector_2_u32(v: @Vector(2, u32), i: usize) void {
11405 expect(v[0] == 7) catch @panic("test failure");
11406 expect(v[1] == 8) catch @panic("test failure");
11407 expect(i == 2) catch @panic("test failure");
11408}
11409
11410extern fn c_ret_vector_2_u32() @Vector(2, u32);
11411extern fn c_vector_2_u32(@Vector(2, u32), usize) void;
11412extern fn c_test_vector_2_u32() void;
11413
11414test "@Vector(2, u32)" {
11415 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11416 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11417 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
11418 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
11419
11420 const v = c_ret_vector_2_u32();
11421 try expect(v[0] == 9);
11422 try expect(v[1] == 10);
11423 c_vector_2_u32(.{ 11, 12 }, 2);
11424 c_test_vector_2_u32();
11425}
11426
11427export fn zig_ret_vector_3_u32() @Vector(3, u32) {
11428 return .{ 13, 14, 15 };
11429}
11430export fn zig_vector_3_u32(v: @Vector(3, u32), i: usize) void {
11431 expect(v[0] == 16) catch @panic("test failure");
11432 expect(v[1] == 17) catch @panic("test failure");
11433 expect(v[2] == 18) catch @panic("test failure");
11434 expect(i == 3) catch @panic("test failure");
11435}
11436
11437extern fn c_ret_vector_3_u32() @Vector(3, u32);
11438extern fn c_vector_3_u32(@Vector(3, u32), usize) void;
11439extern fn c_test_vector_3_u32() void;
11440
11441test "@Vector(3, u32)" {
11442 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
11443 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11444 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
11445
11446 const v = c_ret_vector_3_u32();
11447 try expect(v[0] == 19);
11448 try expect(v[1] == 20);
11449 try expect(v[2] == 21);
11450 c_vector_3_u32(.{ 22, 23, 24 }, 3);
11451 c_test_vector_3_u32();
11452}
11453
11454export fn zig_ret_vector_4_u32() @Vector(4, u32) {
11455 return .{ 25, 26, 27, 28 };
11456}
11457export fn zig_vector_4_u32(v: @Vector(4, u32), i: usize) void {
11458 expect(v[0] == 29) catch @panic("test failure");
11459 expect(v[1] == 30) catch @panic("test failure");
11460 expect(v[2] == 31) catch @panic("test failure");
11461 expect(v[3] == 32) catch @panic("test failure");
11462 expect(i == 4) catch @panic("test failure");
11463}
11464export fn zig_vector_4_u32_vector_4_u32(v0: @Vector(4, u32), v1: @Vector(4, u32), i: usize) void {
11465 expect(v0[0] == 33) catch @panic("test failure");
11466 expect(v0[1] == 34) catch @panic("test failure");
11467 expect(v0[2] == 35) catch @panic("test failure");
11468 expect(v0[3] == 36) catch @panic("test failure");
11469 expect(v1[0] == 37) catch @panic("test failure");
11470 expect(v1[1] == 38) catch @panic("test failure");
11471 expect(v1[2] == 39) catch @panic("test failure");
11472 expect(v1[3] == 40) catch @panic("test failure");
11473 expect(i == 8) catch @panic("test failure");
11474}
11475
11476extern fn c_ret_vector_4_u32() @Vector(4, u32);
11477extern fn c_vector_4_u32(@Vector(4, u32), usize) void;
11478extern fn c_vector_4_u32_vector_4_u32(@Vector(4, u32), @Vector(4, u32), usize) void;
11479extern fn c_test_vector_4_u32() void;
11480
11481test "@Vector(4, u32)" {
11482 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11483
11484 const v = c_ret_vector_4_u32();
11485 try expect(v[0] == 41);
11486 try expect(v[1] == 42);
11487 try expect(v[2] == 43);
11488 try expect(v[3] == 44);
11489 c_vector_4_u32(.{ 45, 46, 47, 48 }, 4);
11490 c_vector_4_u32_vector_4_u32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
11491 c_test_vector_4_u32();
11492}
11493
11494export fn zig_ret_vector_6_u32() @Vector(6, u32) {
11495 return .{ 41, 42, 43, 44, 45, 46 };
11496}
11497export fn zig_vector_6_u32(v: @Vector(6, u32), i: usize) void {
11498 expect(v[0] == 47) catch @panic("test failure");
11499 expect(v[1] == 48) catch @panic("test failure");
11500 expect(v[2] == 49) catch @panic("test failure");
11501 expect(v[3] == 50) catch @panic("test failure");
11502 expect(v[4] == 51) catch @panic("test failure");
11503 expect(v[5] == 52) catch @panic("test failure");
11504 expect(i == 6) catch @panic("test failure");
11505}
11506
11507extern fn c_ret_vector_6_u32() @Vector(6, u32);
11508extern fn c_vector_6_u32(@Vector(6, u32), usize) void;
11509extern fn c_test_vector_6_u32() void;
11510
11511test "@Vector(6, u32)" {
11512 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11513 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11514 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
11515 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11516
11517 const v = c_ret_vector_6_u32();
11518 try expect(v[0] == 53);
11519 try expect(v[1] == 54);
11520 try expect(v[2] == 55);
11521 try expect(v[3] == 56);
11522 try expect(v[4] == 57);
11523 try expect(v[5] == 58);
11524 c_vector_6_u32(.{ 59, 60, 61, 62, 63, 64 }, 6);
11525 c_test_vector_6_u32();
11526}
11527
11528export fn zig_ret_vector_8_u32() @Vector(8, u32) {
11529 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
11530}
11531export fn zig_vector_8_u32(v: @Vector(8, u32), i: usize) void {
11532 expect(v[0] == 73) catch @panic("test failure");
11533 expect(v[1] == 74) catch @panic("test failure");
11534 expect(v[2] == 75) catch @panic("test failure");
11535 expect(v[3] == 76) catch @panic("test failure");
11536 expect(v[4] == 77) catch @panic("test failure");
11537 expect(v[5] == 78) catch @panic("test failure");
11538 expect(v[6] == 79) catch @panic("test failure");
11539 expect(v[7] == 80) catch @panic("test failure");
11540 expect(i == 8) catch @panic("test failure");
11541}
11542
11543extern fn c_ret_vector_8_u32() @Vector(8, u32);
11544extern fn c_vector_8_u32(@Vector(8, u32), usize) void;
11545extern fn c_test_vector_8_u32() void;
11546
11547test "@Vector(8, u32)" {
11548 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11549 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11550 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11551
11552 const v = c_ret_vector_8_u32();
11553 try expect(v[0] == 81);
11554 try expect(v[1] == 82);
11555 try expect(v[2] == 83);
11556 try expect(v[3] == 84);
11557 try expect(v[4] == 85);
11558 try expect(v[5] == 86);
11559 try expect(v[6] == 87);
11560 try expect(v[7] == 88);
11561 c_vector_8_u32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
11562 c_test_vector_8_u32();
11563}
11564
11565export fn zig_ret_vector_12_u32() @Vector(12, u32) {
11566 return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
11567}
11568export fn zig_vector_12_u32(v: @Vector(12, u32), i: usize) void {
11569 expect(v[0] == 109) catch @panic("test failure");
11570 expect(v[1] == 110) catch @panic("test failure");
11571 expect(v[2] == 111) catch @panic("test failure");
11572 expect(v[3] == 112) catch @panic("test failure");
11573 expect(v[4] == 113) catch @panic("test failure");
11574 expect(v[5] == 114) catch @panic("test failure");
11575 expect(v[6] == 115) catch @panic("test failure");
11576 expect(v[7] == 116) catch @panic("test failure");
11577 expect(v[8] == 117) catch @panic("test failure");
11578 expect(v[9] == 118) catch @panic("test failure");
11579 expect(v[10] == 119) catch @panic("test failure");
11580 expect(v[11] == 120) catch @panic("test failure");
11581 expect(i == 12) catch @panic("test failure");
11582}
11583
11584extern fn c_ret_vector_12_u32() @Vector(12, u32);
11585extern fn c_vector_12_u32(@Vector(12, u32), usize) void;
11586extern fn c_test_vector_12_u32() void;
11587
11588test "@Vector(12, u32)" {
11589 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11590 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11591 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
11592 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11593
11594 const v = c_ret_vector_12_u32();
11595 try expect(v[0] == 121);
11596 try expect(v[1] == 122);
11597 try expect(v[2] == 123);
11598 try expect(v[3] == 124);
11599 try expect(v[4] == 125);
11600 try expect(v[5] == 126);
11601 try expect(v[6] == 127);
11602 try expect(v[7] == 128);
11603 try expect(v[8] == 129);
11604 try expect(v[9] == 130);
11605 try expect(v[10] == 131);
11606 try expect(v[11] == 132);
11607 c_vector_12_u32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
11608 c_test_vector_12_u32();
11609}
11610
11611export fn zig_ret_vector_16_u32() @Vector(16, u32) {
11612 return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
11613}
11614export fn zig_vector_16_u32(v: @Vector(16, u32), i: usize) void {
11615 expect(v[0] == 161) catch @panic("test failure");
11616 expect(v[1] == 162) catch @panic("test failure");
11617 expect(v[2] == 163) catch @panic("test failure");
11618 expect(v[3] == 164) catch @panic("test failure");
11619 expect(v[4] == 165) catch @panic("test failure");
11620 expect(v[5] == 166) catch @panic("test failure");
11621 expect(v[6] == 167) catch @panic("test failure");
11622 expect(v[7] == 168) catch @panic("test failure");
11623 expect(v[8] == 169) catch @panic("test failure");
11624 expect(v[9] == 170) catch @panic("test failure");
11625 expect(v[10] == 171) catch @panic("test failure");
11626 expect(v[11] == 172) catch @panic("test failure");
11627 expect(v[12] == 173) catch @panic("test failure");
11628 expect(v[13] == 174) catch @panic("test failure");
11629 expect(v[14] == 175) catch @panic("test failure");
11630 expect(v[15] == 176) catch @panic("test failure");
11631 expect(i == 16) catch @panic("test failure");
11632}
11633
11634extern fn c_ret_vector_16_u32() @Vector(16, u32);
11635extern fn c_vector_16_u32(@Vector(16, u32), usize) void;
11636extern fn c_test_vector_16_u32() void;
11637
11638test "@Vector(16, u32)" {
11639 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11640 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11641 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11642
11643 const v = c_ret_vector_16_u32();
11644 try expect(v[0] == 177);
11645 try expect(v[1] == 178);
11646 try expect(v[2] == 179);
11647 try expect(v[3] == 180);
11648 try expect(v[4] == 181);
11649 try expect(v[5] == 182);
11650 try expect(v[6] == 183);
11651 try expect(v[7] == 184);
11652 try expect(v[8] == 185);
11653 try expect(v[9] == 186);
11654 try expect(v[10] == 187);
11655 try expect(v[11] == 188);
11656 try expect(v[12] == 189);
11657 try expect(v[13] == 190);
11658 try expect(v[14] == 191);
11659 try expect(v[15] == 192);
11660 c_vector_16_u32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
11661 c_test_vector_16_u32();
11662}
11663
11664export fn zig_ret_vector_24_u32() @Vector(24, u32) {
11665 return .{
11666 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
11667 225, 226, 227, 228, 229, 230, 231, 232,
11668 };
11669}
11670export fn zig_vector_24_u32(v: @Vector(24, u32), i: usize) void {
11671 expect(v[0] == 233) catch @panic("test failure");
11672 expect(v[1] == 234) catch @panic("test failure");
11673 expect(v[2] == 235) catch @panic("test failure");
11674 expect(v[3] == 236) catch @panic("test failure");
11675 expect(v[4] == 237) catch @panic("test failure");
11676 expect(v[5] == 238) catch @panic("test failure");
11677 expect(v[6] == 239) catch @panic("test failure");
11678 expect(v[7] == 240) catch @panic("test failure");
11679 expect(v[8] == 241) catch @panic("test failure");
11680 expect(v[9] == 242) catch @panic("test failure");
11681 expect(v[10] == 243) catch @panic("test failure");
11682 expect(v[11] == 244) catch @panic("test failure");
11683 expect(v[12] == 245) catch @panic("test failure");
11684 expect(v[13] == 246) catch @panic("test failure");
11685 expect(v[14] == 247) catch @panic("test failure");
11686 expect(v[15] == 248) catch @panic("test failure");
11687 expect(v[16] == 249) catch @panic("test failure");
11688 expect(v[17] == 250) catch @panic("test failure");
11689 expect(v[18] == 251) catch @panic("test failure");
11690 expect(v[19] == 252) catch @panic("test failure");
11691 expect(v[20] == 253) catch @panic("test failure");
11692 expect(v[21] == 254) catch @panic("test failure");
11693 expect(v[22] == 255) catch @panic("test failure");
11694 expect(v[23] == 256) catch @panic("test failure");
11695 expect(i == 24) catch @panic("test failure");
11696}
11697
11698extern fn c_ret_vector_24_u32() @Vector(24, u32);
11699extern fn c_vector_24_u32(@Vector(24, u32), usize) void;
11700extern fn c_test_vector_24_u32() void;
11701
11702test "@Vector(24, u32)" {
11703 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11704 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11705 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
11706 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11707
11708 const v = c_ret_vector_24_u32();
11709 try expect(v[0] == 257);
11710 try expect(v[1] == 258);
11711 try expect(v[2] == 259);
11712 try expect(v[3] == 260);
11713 try expect(v[4] == 261);
11714 try expect(v[5] == 262);
11715 try expect(v[6] == 263);
11716 try expect(v[7] == 264);
11717 try expect(v[8] == 265);
11718 try expect(v[9] == 266);
11719 try expect(v[10] == 267);
11720 try expect(v[11] == 268);
11721 try expect(v[12] == 269);
11722 try expect(v[13] == 270);
11723 try expect(v[14] == 271);
11724 try expect(v[15] == 272);
11725 try expect(v[16] == 273);
11726 try expect(v[17] == 274);
11727 try expect(v[18] == 275);
11728 try expect(v[19] == 276);
11729 try expect(v[20] == 277);
11730 try expect(v[21] == 278);
11731 try expect(v[22] == 279);
11732 try expect(v[23] == 280);
11733 c_vector_24_u32(.{
11734 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
11735 297, 298, 299, 300, 301, 302, 303, 304,
11736 }, 24);
11737 c_test_vector_24_u32();
11738}
11739
11740export fn zig_ret_vector_32_u32() @Vector(32, u32) {
11741 return .{
11742 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
11743 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
11744 };
11745}
11746export fn zig_vector_32_u32(v: @Vector(32, u32), i: usize) void {
11747 expect(v[0] == 337) catch @panic("test failure");
11748 expect(v[1] == 338) catch @panic("test failure");
11749 expect(v[2] == 339) catch @panic("test failure");
11750 expect(v[3] == 340) catch @panic("test failure");
11751 expect(v[4] == 341) catch @panic("test failure");
11752 expect(v[5] == 342) catch @panic("test failure");
11753 expect(v[6] == 343) catch @panic("test failure");
11754 expect(v[7] == 344) catch @panic("test failure");
11755 expect(v[8] == 345) catch @panic("test failure");
11756 expect(v[9] == 346) catch @panic("test failure");
11757 expect(v[10] == 347) catch @panic("test failure");
11758 expect(v[11] == 348) catch @panic("test failure");
11759 expect(v[12] == 349) catch @panic("test failure");
11760 expect(v[13] == 350) catch @panic("test failure");
11761 expect(v[14] == 351) catch @panic("test failure");
11762 expect(v[15] == 352) catch @panic("test failure");
11763 expect(v[16] == 353) catch @panic("test failure");
11764 expect(v[17] == 354) catch @panic("test failure");
11765 expect(v[18] == 355) catch @panic("test failure");
11766 expect(v[19] == 356) catch @panic("test failure");
11767 expect(v[20] == 357) catch @panic("test failure");
11768 expect(v[21] == 358) catch @panic("test failure");
11769 expect(v[22] == 359) catch @panic("test failure");
11770 expect(v[23] == 360) catch @panic("test failure");
11771 expect(v[24] == 361) catch @panic("test failure");
11772 expect(v[25] == 362) catch @panic("test failure");
11773 expect(v[26] == 363) catch @panic("test failure");
11774 expect(v[27] == 364) catch @panic("test failure");
11775 expect(v[28] == 365) catch @panic("test failure");
11776 expect(v[29] == 366) catch @panic("test failure");
11777 expect(v[30] == 367) catch @panic("test failure");
11778 expect(v[31] == 368) catch @panic("test failure");
11779 expect(i == 32) catch @panic("test failure");
11780}
11781
11782extern fn c_ret_vector_32_u32() @Vector(32, u32);
11783extern fn c_vector_32_u32(@Vector(32, u32), usize) void;
11784extern fn c_test_vector_32_u32() void;
11785
11786test "@Vector(32, u32)" {
11787 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11788 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11789 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
11790 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11791
11792 const v = c_ret_vector_32_u32();
11793 try expect(v[0] == 369);
11794 try expect(v[1] == 370);
11795 try expect(v[2] == 371);
11796 try expect(v[3] == 372);
11797 try expect(v[4] == 373);
11798 try expect(v[5] == 374);
11799 try expect(v[6] == 375);
11800 try expect(v[7] == 376);
11801 try expect(v[8] == 377);
11802 try expect(v[9] == 378);
11803 try expect(v[10] == 379);
11804 try expect(v[11] == 380);
11805 try expect(v[12] == 381);
11806 try expect(v[13] == 382);
11807 try expect(v[14] == 383);
11808 try expect(v[15] == 384);
11809 try expect(v[16] == 385);
11810 try expect(v[17] == 386);
11811 try expect(v[18] == 387);
11812 try expect(v[19] == 388);
11813 try expect(v[20] == 389);
11814 try expect(v[21] == 390);
11815 try expect(v[22] == 391);
11816 try expect(v[23] == 392);
11817 try expect(v[24] == 393);
11818 try expect(v[25] == 394);
11819 try expect(v[26] == 395);
11820 try expect(v[27] == 396);
11821 try expect(v[28] == 397);
11822 try expect(v[29] == 398);
11823 try expect(v[30] == 399);
11824 try expect(v[31] == 400);
11825 c_vector_32_u32(.{
11826 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
11827 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
11828 }, 32);
11829 c_test_vector_32_u32();
11830}
11831
11832export fn zig_ret_vector_48_u32() @Vector(48, u32) {
11833 return .{
11834 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
11835 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
11836 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
11837 };
11838}
11839export fn zig_vector_48_u32(v: @Vector(48, u32), i: usize) void {
11840 expect(v[0] == 481) catch @panic("test failure");
11841 expect(v[1] == 482) catch @panic("test failure");
11842 expect(v[2] == 483) catch @panic("test failure");
11843 expect(v[3] == 484) catch @panic("test failure");
11844 expect(v[4] == 485) catch @panic("test failure");
11845 expect(v[5] == 486) catch @panic("test failure");
11846 expect(v[6] == 487) catch @panic("test failure");
11847 expect(v[7] == 488) catch @panic("test failure");
11848 expect(v[8] == 489) catch @panic("test failure");
11849 expect(v[9] == 490) catch @panic("test failure");
11850 expect(v[10] == 491) catch @panic("test failure");
11851 expect(v[11] == 492) catch @panic("test failure");
11852 expect(v[12] == 493) catch @panic("test failure");
11853 expect(v[13] == 494) catch @panic("test failure");
11854 expect(v[14] == 495) catch @panic("test failure");
11855 expect(v[15] == 496) catch @panic("test failure");
11856 expect(v[16] == 497) catch @panic("test failure");
11857 expect(v[17] == 498) catch @panic("test failure");
11858 expect(v[18] == 499) catch @panic("test failure");
11859 expect(v[19] == 500) catch @panic("test failure");
11860 expect(v[20] == 501) catch @panic("test failure");
11861 expect(v[21] == 502) catch @panic("test failure");
11862 expect(v[22] == 503) catch @panic("test failure");
11863 expect(v[23] == 504) catch @panic("test failure");
11864 expect(v[24] == 505) catch @panic("test failure");
11865 expect(v[25] == 506) catch @panic("test failure");
11866 expect(v[26] == 507) catch @panic("test failure");
11867 expect(v[27] == 508) catch @panic("test failure");
11868 expect(v[28] == 509) catch @panic("test failure");
11869 expect(v[29] == 510) catch @panic("test failure");
11870 expect(v[30] == 511) catch @panic("test failure");
11871 expect(v[31] == 512) catch @panic("test failure");
11872 expect(v[32] == 513) catch @panic("test failure");
11873 expect(v[33] == 514) catch @panic("test failure");
11874 expect(v[34] == 515) catch @panic("test failure");
11875 expect(v[35] == 516) catch @panic("test failure");
11876 expect(v[36] == 517) catch @panic("test failure");
11877 expect(v[37] == 518) catch @panic("test failure");
11878 expect(v[38] == 519) catch @panic("test failure");
11879 expect(v[39] == 520) catch @panic("test failure");
11880 expect(v[40] == 521) catch @panic("test failure");
11881 expect(v[41] == 522) catch @panic("test failure");
11882 expect(v[42] == 523) catch @panic("test failure");
11883 expect(v[43] == 524) catch @panic("test failure");
11884 expect(v[44] == 525) catch @panic("test failure");
11885 expect(v[45] == 526) catch @panic("test failure");
11886 expect(v[46] == 527) catch @panic("test failure");
11887 expect(v[47] == 528) catch @panic("test failure");
11888 expect(i == 48) catch @panic("test failure");
11889}
11890
11891extern fn c_ret_vector_48_u32() @Vector(48, u32);
11892extern fn c_vector_48_u32(@Vector(48, u32), usize) void;
11893extern fn c_test_vector_48_u32() void;
11894
11895test "@Vector(48, u32)" {
11896 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
11897 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
11898 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
11899 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
11900
11901 const v = c_ret_vector_48_u32();
11902 try expect(v[0] == 529);
11903 try expect(v[1] == 530);
11904 try expect(v[2] == 531);
11905 try expect(v[3] == 532);
11906 try expect(v[4] == 533);
11907 try expect(v[5] == 534);
11908 try expect(v[6] == 535);
11909 try expect(v[7] == 536);
11910 try expect(v[8] == 537);
11911 try expect(v[9] == 538);
11912 try expect(v[10] == 539);
11913 try expect(v[11] == 540);
11914 try expect(v[12] == 541);
11915 try expect(v[13] == 542);
11916 try expect(v[14] == 543);
11917 try expect(v[15] == 544);
11918 try expect(v[16] == 545);
11919 try expect(v[17] == 546);
11920 try expect(v[18] == 547);
11921 try expect(v[19] == 548);
11922 try expect(v[20] == 549);
11923 try expect(v[21] == 550);
11924 try expect(v[22] == 551);
11925 try expect(v[23] == 552);
11926 try expect(v[24] == 553);
11927 try expect(v[25] == 554);
11928 try expect(v[26] == 555);
11929 try expect(v[27] == 556);
11930 try expect(v[28] == 557);
11931 try expect(v[29] == 558);
11932 try expect(v[30] == 559);
11933 try expect(v[31] == 560);
11934 try expect(v[32] == 561);
11935 try expect(v[33] == 562);
11936 try expect(v[34] == 563);
11937 try expect(v[35] == 564);
11938 try expect(v[36] == 565);
11939 try expect(v[37] == 566);
11940 try expect(v[38] == 567);
11941 try expect(v[39] == 568);
11942 try expect(v[40] == 569);
11943 try expect(v[41] == 570);
11944 try expect(v[42] == 571);
11945 try expect(v[43] == 572);
11946 try expect(v[44] == 573);
11947 try expect(v[45] == 574);
11948 try expect(v[46] == 575);
11949 try expect(v[47] == 576);
11950 c_vector_48_u32(.{
11951 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
11952 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
11953 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
11954 }, 48);
11955 c_test_vector_48_u32();
11956}
11957
11958export fn zig_ret_vector_64_u32() @Vector(64, u32) {
11959 return .{
11960 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
11961 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
11962 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
11963 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
11964 };
11965}
11966export fn zig_vector_64_u32(v: @Vector(64, u32), i: usize) void {
11967 expect(v[0] == 689) catch @panic("test failure");
11968 expect(v[1] == 690) catch @panic("test failure");
11969 expect(v[2] == 691) catch @panic("test failure");
11970 expect(v[3] == 692) catch @panic("test failure");
11971 expect(v[4] == 693) catch @panic("test failure");
11972 expect(v[5] == 694) catch @panic("test failure");
11973 expect(v[6] == 695) catch @panic("test failure");
11974 expect(v[7] == 696) catch @panic("test failure");
11975 expect(v[8] == 697) catch @panic("test failure");
11976 expect(v[9] == 698) catch @panic("test failure");
11977 expect(v[10] == 699) catch @panic("test failure");
11978 expect(v[11] == 700) catch @panic("test failure");
11979 expect(v[12] == 701) catch @panic("test failure");
11980 expect(v[13] == 702) catch @panic("test failure");
11981 expect(v[14] == 703) catch @panic("test failure");
11982 expect(v[15] == 704) catch @panic("test failure");
11983 expect(v[16] == 705) catch @panic("test failure");
11984 expect(v[17] == 706) catch @panic("test failure");
11985 expect(v[18] == 707) catch @panic("test failure");
11986 expect(v[19] == 708) catch @panic("test failure");
11987 expect(v[20] == 709) catch @panic("test failure");
11988 expect(v[21] == 710) catch @panic("test failure");
11989 expect(v[22] == 711) catch @panic("test failure");
11990 expect(v[23] == 712) catch @panic("test failure");
11991 expect(v[24] == 713) catch @panic("test failure");
11992 expect(v[25] == 714) catch @panic("test failure");
11993 expect(v[26] == 715) catch @panic("test failure");
11994 expect(v[27] == 716) catch @panic("test failure");
11995 expect(v[28] == 717) catch @panic("test failure");
11996 expect(v[29] == 718) catch @panic("test failure");
11997 expect(v[30] == 719) catch @panic("test failure");
11998 expect(v[31] == 720) catch @panic("test failure");
11999 expect(v[32] == 721) catch @panic("test failure");
12000 expect(v[33] == 722) catch @panic("test failure");
12001 expect(v[34] == 723) catch @panic("test failure");
12002 expect(v[35] == 724) catch @panic("test failure");
12003 expect(v[36] == 725) catch @panic("test failure");
12004 expect(v[37] == 726) catch @panic("test failure");
12005 expect(v[38] == 727) catch @panic("test failure");
12006 expect(v[39] == 728) catch @panic("test failure");
12007 expect(v[40] == 729) catch @panic("test failure");
12008 expect(v[41] == 730) catch @panic("test failure");
12009 expect(v[42] == 731) catch @panic("test failure");
12010 expect(v[43] == 732) catch @panic("test failure");
12011 expect(v[44] == 733) catch @panic("test failure");
12012 expect(v[45] == 734) catch @panic("test failure");
12013 expect(v[46] == 735) catch @panic("test failure");
12014 expect(v[47] == 736) catch @panic("test failure");
12015 expect(v[48] == 737) catch @panic("test failure");
12016 expect(v[49] == 738) catch @panic("test failure");
12017 expect(v[50] == 739) catch @panic("test failure");
12018 expect(v[51] == 740) catch @panic("test failure");
12019 expect(v[52] == 741) catch @panic("test failure");
12020 expect(v[53] == 742) catch @panic("test failure");
12021 expect(v[54] == 743) catch @panic("test failure");
12022 expect(v[55] == 744) catch @panic("test failure");
12023 expect(v[56] == 745) catch @panic("test failure");
12024 expect(v[57] == 746) catch @panic("test failure");
12025 expect(v[58] == 747) catch @panic("test failure");
12026 expect(v[59] == 748) catch @panic("test failure");
12027 expect(v[60] == 749) catch @panic("test failure");
12028 expect(v[61] == 750) catch @panic("test failure");
12029 expect(v[62] == 751) catch @panic("test failure");
12030 expect(v[63] == 752) catch @panic("test failure");
12031 expect(i == 64) catch @panic("test failure");
12032}
12033
12034extern fn c_ret_vector_64_u32() @Vector(64, u32);
12035extern fn c_vector_64_u32(@Vector(64, u32), usize) void;
12036extern fn c_test_vector_64_u32() void;
12037
12038test "@Vector(64, u32)" {
12039 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12040 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12041 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
12042 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12043
12044 const v = c_ret_vector_64_u32();
12045 try expect(v[0] == 753);
12046 try expect(v[1] == 754);
12047 try expect(v[2] == 755);
12048 try expect(v[3] == 756);
12049 try expect(v[4] == 757);
12050 try expect(v[5] == 758);
12051 try expect(v[6] == 759);
12052 try expect(v[7] == 760);
12053 try expect(v[8] == 761);
12054 try expect(v[9] == 762);
12055 try expect(v[10] == 763);
12056 try expect(v[11] == 764);
12057 try expect(v[12] == 765);
12058 try expect(v[13] == 766);
12059 try expect(v[14] == 767);
12060 try expect(v[15] == 768);
12061 try expect(v[16] == 769);
12062 try expect(v[17] == 770);
12063 try expect(v[18] == 771);
12064 try expect(v[19] == 772);
12065 try expect(v[20] == 773);
12066 try expect(v[21] == 774);
12067 try expect(v[22] == 775);
12068 try expect(v[23] == 776);
12069 try expect(v[24] == 777);
12070 try expect(v[25] == 778);
12071 try expect(v[26] == 779);
12072 try expect(v[27] == 780);
12073 try expect(v[28] == 781);
12074 try expect(v[29] == 782);
12075 try expect(v[30] == 783);
12076 try expect(v[31] == 784);
12077 try expect(v[32] == 785);
12078 try expect(v[33] == 786);
12079 try expect(v[34] == 787);
12080 try expect(v[35] == 788);
12081 try expect(v[36] == 789);
12082 try expect(v[37] == 790);
12083 try expect(v[38] == 791);
12084 try expect(v[39] == 792);
12085 try expect(v[40] == 793);
12086 try expect(v[41] == 794);
12087 try expect(v[42] == 795);
12088 try expect(v[43] == 796);
12089 try expect(v[44] == 797);
12090 try expect(v[45] == 798);
12091 try expect(v[46] == 799);
12092 try expect(v[47] == 800);
12093 try expect(v[48] == 801);
12094 try expect(v[49] == 802);
12095 try expect(v[50] == 803);
12096 try expect(v[51] == 804);
12097 try expect(v[52] == 805);
12098 try expect(v[53] == 806);
12099 try expect(v[54] == 807);
12100 try expect(v[55] == 808);
12101 try expect(v[56] == 809);
12102 try expect(v[57] == 810);
12103 try expect(v[58] == 811);
12104 try expect(v[59] == 812);
12105 try expect(v[60] == 813);
12106 try expect(v[61] == 814);
12107 try expect(v[62] == 815);
12108 try expect(v[63] == 816);
12109 c_vector_64_u32(.{
12110 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
12111 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
12112 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
12113 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
12114 }, 64);
12115 c_test_vector_64_u32();
12116}
12117
12118export fn zig_ret_vector_96_u32() @Vector(96, u32) {
12119 return .{
12120 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
12121 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
12122 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
12123 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
12124 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
12125 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
12126 };
12127}
12128export fn zig_vector_96_u32(v: @Vector(96, u32), i: usize) void {
12129 expect(v[0] == 986) catch @panic("test failure");
12130 expect(v[1] == 987) catch @panic("test failure");
12131 expect(v[2] == 988) catch @panic("test failure");
12132 expect(v[3] == 989) catch @panic("test failure");
12133 expect(v[4] == 990) catch @panic("test failure");
12134 expect(v[5] == 991) catch @panic("test failure");
12135 expect(v[6] == 992) catch @panic("test failure");
12136 expect(v[7] == 993) catch @panic("test failure");
12137 expect(v[8] == 994) catch @panic("test failure");
12138 expect(v[9] == 995) catch @panic("test failure");
12139 expect(v[10] == 996) catch @panic("test failure");
12140 expect(v[11] == 997) catch @panic("test failure");
12141 expect(v[12] == 998) catch @panic("test failure");
12142 expect(v[13] == 999) catch @panic("test failure");
12143 expect(v[14] == 1000) catch @panic("test failure");
12144 expect(v[15] == 1001) catch @panic("test failure");
12145 expect(v[16] == 1002) catch @panic("test failure");
12146 expect(v[17] == 1003) catch @panic("test failure");
12147 expect(v[18] == 1004) catch @panic("test failure");
12148 expect(v[19] == 1005) catch @panic("test failure");
12149 expect(v[20] == 1006) catch @panic("test failure");
12150 expect(v[21] == 1007) catch @panic("test failure");
12151 expect(v[22] == 1008) catch @panic("test failure");
12152 expect(v[23] == 1009) catch @panic("test failure");
12153 expect(v[24] == 1010) catch @panic("test failure");
12154 expect(v[25] == 1011) catch @panic("test failure");
12155 expect(v[26] == 1012) catch @panic("test failure");
12156 expect(v[27] == 1013) catch @panic("test failure");
12157 expect(v[28] == 1014) catch @panic("test failure");
12158 expect(v[29] == 1015) catch @panic("test failure");
12159 expect(v[30] == 1016) catch @panic("test failure");
12160 expect(v[31] == 1017) catch @panic("test failure");
12161 expect(v[32] == 1018) catch @panic("test failure");
12162 expect(v[33] == 1019) catch @panic("test failure");
12163 expect(v[34] == 1020) catch @panic("test failure");
12164 expect(v[35] == 1021) catch @panic("test failure");
12165 expect(v[36] == 1022) catch @panic("test failure");
12166 expect(v[37] == 1023) catch @panic("test failure");
12167 expect(v[38] == 1024) catch @panic("test failure");
12168 expect(v[39] == 1025) catch @panic("test failure");
12169 expect(v[40] == 1026) catch @panic("test failure");
12170 expect(v[41] == 1027) catch @panic("test failure");
12171 expect(v[42] == 1028) catch @panic("test failure");
12172 expect(v[43] == 1029) catch @panic("test failure");
12173 expect(v[44] == 1030) catch @panic("test failure");
12174 expect(v[45] == 1031) catch @panic("test failure");
12175 expect(v[46] == 1032) catch @panic("test failure");
12176 expect(v[47] == 1033) catch @panic("test failure");
12177 expect(v[48] == 1034) catch @panic("test failure");
12178 expect(v[49] == 1035) catch @panic("test failure");
12179 expect(v[50] == 1036) catch @panic("test failure");
12180 expect(v[51] == 1037) catch @panic("test failure");
12181 expect(v[52] == 1038) catch @panic("test failure");
12182 expect(v[53] == 1039) catch @panic("test failure");
12183 expect(v[54] == 1040) catch @panic("test failure");
12184 expect(v[55] == 1041) catch @panic("test failure");
12185 expect(v[56] == 1042) catch @panic("test failure");
12186 expect(v[57] == 1043) catch @panic("test failure");
12187 expect(v[58] == 1044) catch @panic("test failure");
12188 expect(v[59] == 1045) catch @panic("test failure");
12189 expect(v[60] == 1046) catch @panic("test failure");
12190 expect(v[61] == 1047) catch @panic("test failure");
12191 expect(v[62] == 1048) catch @panic("test failure");
12192 expect(v[63] == 1049) catch @panic("test failure");
12193 expect(v[64] == 1050) catch @panic("test failure");
12194 expect(v[65] == 1051) catch @panic("test failure");
12195 expect(v[66] == 1052) catch @panic("test failure");
12196 expect(v[67] == 1053) catch @panic("test failure");
12197 expect(v[68] == 1054) catch @panic("test failure");
12198 expect(v[69] == 1055) catch @panic("test failure");
12199 expect(v[70] == 1056) catch @panic("test failure");
12200 expect(v[71] == 1057) catch @panic("test failure");
12201 expect(v[72] == 1058) catch @panic("test failure");
12202 expect(v[73] == 1059) catch @panic("test failure");
12203 expect(v[74] == 1060) catch @panic("test failure");
12204 expect(v[75] == 1061) catch @panic("test failure");
12205 expect(v[76] == 1062) catch @panic("test failure");
12206 expect(v[77] == 1063) catch @panic("test failure");
12207 expect(v[78] == 1064) catch @panic("test failure");
12208 expect(v[79] == 1065) catch @panic("test failure");
12209 expect(v[80] == 1066) catch @panic("test failure");
12210 expect(v[81] == 1067) catch @panic("test failure");
12211 expect(v[82] == 1068) catch @panic("test failure");
12212 expect(v[83] == 1069) catch @panic("test failure");
12213 expect(v[84] == 1070) catch @panic("test failure");
12214 expect(v[85] == 1071) catch @panic("test failure");
12215 expect(v[86] == 1072) catch @panic("test failure");
12216 expect(v[87] == 1073) catch @panic("test failure");
12217 expect(v[88] == 1074) catch @panic("test failure");
12218 expect(v[89] == 1075) catch @panic("test failure");
12219 expect(v[90] == 1076) catch @panic("test failure");
12220 expect(v[91] == 1077) catch @panic("test failure");
12221 expect(v[92] == 1078) catch @panic("test failure");
12222 expect(v[93] == 1079) catch @panic("test failure");
12223 expect(v[94] == 1080) catch @panic("test failure");
12224 expect(v[95] == 1081) catch @panic("test failure");
12225 expect(i == 96) catch @panic("test failure");
12226}
12227
12228extern fn c_ret_vector_96_u32() @Vector(96, u32);
12229extern fn c_vector_96_u32(@Vector(96, u32), usize) void;
12230extern fn c_test_vector_96_u32() void;
12231
12232test "@Vector(96, u32)" {
12233 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12234 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12235 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
12236 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12237
12238 const v = c_ret_vector_96_u32();
12239 try expect(v[0] == 1082);
12240 try expect(v[1] == 1083);
12241 try expect(v[2] == 1084);
12242 try expect(v[3] == 1085);
12243 try expect(v[4] == 1086);
12244 try expect(v[5] == 1087);
12245 try expect(v[6] == 1088);
12246 try expect(v[7] == 1089);
12247 try expect(v[8] == 1090);
12248 try expect(v[9] == 1091);
12249 try expect(v[10] == 1092);
12250 try expect(v[11] == 1093);
12251 try expect(v[12] == 1094);
12252 try expect(v[13] == 1095);
12253 try expect(v[14] == 1096);
12254 try expect(v[15] == 1097);
12255 try expect(v[16] == 1098);
12256 try expect(v[17] == 1099);
12257 try expect(v[18] == 1100);
12258 try expect(v[19] == 1101);
12259 try expect(v[20] == 1102);
12260 try expect(v[21] == 1103);
12261 try expect(v[22] == 1104);
12262 try expect(v[23] == 1105);
12263 try expect(v[24] == 1106);
12264 try expect(v[25] == 1107);
12265 try expect(v[26] == 1108);
12266 try expect(v[27] == 1109);
12267 try expect(v[28] == 1110);
12268 try expect(v[29] == 1111);
12269 try expect(v[30] == 1112);
12270 try expect(v[31] == 1113);
12271 try expect(v[32] == 1114);
12272 try expect(v[33] == 1115);
12273 try expect(v[34] == 1116);
12274 try expect(v[35] == 1117);
12275 try expect(v[36] == 1118);
12276 try expect(v[37] == 1119);
12277 try expect(v[38] == 1120);
12278 try expect(v[39] == 1121);
12279 try expect(v[40] == 1122);
12280 try expect(v[41] == 1123);
12281 try expect(v[42] == 1124);
12282 try expect(v[43] == 1125);
12283 try expect(v[44] == 1126);
12284 try expect(v[45] == 1127);
12285 try expect(v[46] == 1128);
12286 try expect(v[47] == 1129);
12287 try expect(v[48] == 1130);
12288 try expect(v[49] == 1131);
12289 try expect(v[50] == 1132);
12290 try expect(v[51] == 1133);
12291 try expect(v[52] == 1134);
12292 try expect(v[53] == 1135);
12293 try expect(v[54] == 1136);
12294 try expect(v[55] == 1137);
12295 try expect(v[56] == 1138);
12296 try expect(v[57] == 1139);
12297 try expect(v[58] == 1140);
12298 try expect(v[59] == 1141);
12299 try expect(v[60] == 1142);
12300 try expect(v[61] == 1143);
12301 try expect(v[62] == 1144);
12302 try expect(v[63] == 1145);
12303 try expect(v[64] == 1146);
12304 try expect(v[65] == 1147);
12305 try expect(v[66] == 1148);
12306 try expect(v[67] == 1149);
12307 try expect(v[68] == 1150);
12308 try expect(v[69] == 1151);
12309 try expect(v[70] == 1152);
12310 try expect(v[71] == 1153);
12311 try expect(v[72] == 1154);
12312 try expect(v[73] == 1155);
12313 try expect(v[74] == 1156);
12314 try expect(v[75] == 1157);
12315 try expect(v[76] == 1158);
12316 try expect(v[77] == 1159);
12317 try expect(v[78] == 1160);
12318 try expect(v[79] == 1161);
12319 try expect(v[80] == 1162);
12320 try expect(v[81] == 1163);
12321 try expect(v[82] == 1164);
12322 try expect(v[83] == 1165);
12323 try expect(v[84] == 1166);
12324 try expect(v[85] == 1167);
12325 try expect(v[86] == 1168);
12326 try expect(v[87] == 1169);
12327 try expect(v[88] == 1170);
12328 try expect(v[89] == 1171);
12329 try expect(v[90] == 1172);
12330 try expect(v[91] == 1173);
12331 try expect(v[92] == 1174);
12332 try expect(v[93] == 1175);
12333 try expect(v[94] == 1176);
12334 try expect(v[95] == 1177);
12335 c_vector_96_u32(.{
12336 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
12337 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
12338 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
12339 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
12340 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
12341 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
12342 }, 96);
12343 c_test_vector_96_u32();
12344}
12345
12346export fn zig_ret_vector_128_u32() @Vector(128, u32) {
12347 return .{
12348 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
12349 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
12350 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
12351 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
12352 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
12353 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
12354 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
12355 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
12356 };
12357}
12358export fn zig_vector_128_u32(v: @Vector(128, u32), i: usize) void {
12359 expect(v[0] == 1402) catch @panic("test failure");
12360 expect(v[1] == 1403) catch @panic("test failure");
12361 expect(v[2] == 1404) catch @panic("test failure");
12362 expect(v[3] == 1405) catch @panic("test failure");
12363 expect(v[4] == 1406) catch @panic("test failure");
12364 expect(v[5] == 1407) catch @panic("test failure");
12365 expect(v[6] == 1408) catch @panic("test failure");
12366 expect(v[7] == 1409) catch @panic("test failure");
12367 expect(v[8] == 1410) catch @panic("test failure");
12368 expect(v[9] == 1411) catch @panic("test failure");
12369 expect(v[10] == 1412) catch @panic("test failure");
12370 expect(v[11] == 1413) catch @panic("test failure");
12371 expect(v[12] == 1414) catch @panic("test failure");
12372 expect(v[13] == 1415) catch @panic("test failure");
12373 expect(v[14] == 1416) catch @panic("test failure");
12374 expect(v[15] == 1417) catch @panic("test failure");
12375 expect(v[16] == 1418) catch @panic("test failure");
12376 expect(v[17] == 1419) catch @panic("test failure");
12377 expect(v[18] == 1420) catch @panic("test failure");
12378 expect(v[19] == 1421) catch @panic("test failure");
12379 expect(v[20] == 1422) catch @panic("test failure");
12380 expect(v[21] == 1423) catch @panic("test failure");
12381 expect(v[22] == 1424) catch @panic("test failure");
12382 expect(v[23] == 1425) catch @panic("test failure");
12383 expect(v[24] == 1426) catch @panic("test failure");
12384 expect(v[25] == 1427) catch @panic("test failure");
12385 expect(v[26] == 1428) catch @panic("test failure");
12386 expect(v[27] == 1429) catch @panic("test failure");
12387 expect(v[28] == 1430) catch @panic("test failure");
12388 expect(v[29] == 1431) catch @panic("test failure");
12389 expect(v[30] == 1432) catch @panic("test failure");
12390 expect(v[31] == 1433) catch @panic("test failure");
12391 expect(v[32] == 1434) catch @panic("test failure");
12392 expect(v[33] == 1435) catch @panic("test failure");
12393 expect(v[34] == 1436) catch @panic("test failure");
12394 expect(v[35] == 1437) catch @panic("test failure");
12395 expect(v[36] == 1438) catch @panic("test failure");
12396 expect(v[37] == 1439) catch @panic("test failure");
12397 expect(v[38] == 1440) catch @panic("test failure");
12398 expect(v[39] == 1441) catch @panic("test failure");
12399 expect(v[40] == 1442) catch @panic("test failure");
12400 expect(v[41] == 1443) catch @panic("test failure");
12401 expect(v[42] == 1444) catch @panic("test failure");
12402 expect(v[43] == 1445) catch @panic("test failure");
12403 expect(v[44] == 1446) catch @panic("test failure");
12404 expect(v[45] == 1447) catch @panic("test failure");
12405 expect(v[46] == 1448) catch @panic("test failure");
12406 expect(v[47] == 1449) catch @panic("test failure");
12407 expect(v[48] == 1450) catch @panic("test failure");
12408 expect(v[49] == 1451) catch @panic("test failure");
12409 expect(v[50] == 1452) catch @panic("test failure");
12410 expect(v[51] == 1453) catch @panic("test failure");
12411 expect(v[52] == 1454) catch @panic("test failure");
12412 expect(v[53] == 1455) catch @panic("test failure");
12413 expect(v[54] == 1456) catch @panic("test failure");
12414 expect(v[55] == 1457) catch @panic("test failure");
12415 expect(v[56] == 1458) catch @panic("test failure");
12416 expect(v[57] == 1459) catch @panic("test failure");
12417 expect(v[58] == 1460) catch @panic("test failure");
12418 expect(v[59] == 1461) catch @panic("test failure");
12419 expect(v[60] == 1462) catch @panic("test failure");
12420 expect(v[61] == 1463) catch @panic("test failure");
12421 expect(v[62] == 1464) catch @panic("test failure");
12422 expect(v[63] == 1465) catch @panic("test failure");
12423 expect(v[64] == 1466) catch @panic("test failure");
12424 expect(v[65] == 1467) catch @panic("test failure");
12425 expect(v[66] == 1468) catch @panic("test failure");
12426 expect(v[67] == 1469) catch @panic("test failure");
12427 expect(v[68] == 1470) catch @panic("test failure");
12428 expect(v[69] == 1471) catch @panic("test failure");
12429 expect(v[70] == 1472) catch @panic("test failure");
12430 expect(v[71] == 1473) catch @panic("test failure");
12431 expect(v[72] == 1474) catch @panic("test failure");
12432 expect(v[73] == 1475) catch @panic("test failure");
12433 expect(v[74] == 1476) catch @panic("test failure");
12434 expect(v[75] == 1477) catch @panic("test failure");
12435 expect(v[76] == 1478) catch @panic("test failure");
12436 expect(v[77] == 1479) catch @panic("test failure");
12437 expect(v[78] == 1480) catch @panic("test failure");
12438 expect(v[79] == 1481) catch @panic("test failure");
12439 expect(v[80] == 1482) catch @panic("test failure");
12440 expect(v[81] == 1483) catch @panic("test failure");
12441 expect(v[82] == 1484) catch @panic("test failure");
12442 expect(v[83] == 1485) catch @panic("test failure");
12443 expect(v[84] == 1486) catch @panic("test failure");
12444 expect(v[85] == 1487) catch @panic("test failure");
12445 expect(v[86] == 1488) catch @panic("test failure");
12446 expect(v[87] == 1489) catch @panic("test failure");
12447 expect(v[88] == 1490) catch @panic("test failure");
12448 expect(v[89] == 1491) catch @panic("test failure");
12449 expect(v[90] == 1492) catch @panic("test failure");
12450 expect(v[91] == 1493) catch @panic("test failure");
12451 expect(v[92] == 1494) catch @panic("test failure");
12452 expect(v[93] == 1495) catch @panic("test failure");
12453 expect(v[94] == 1496) catch @panic("test failure");
12454 expect(v[95] == 1497) catch @panic("test failure");
12455 expect(v[96] == 1498) catch @panic("test failure");
12456 expect(v[97] == 1499) catch @panic("test failure");
12457 expect(v[98] == 1500) catch @panic("test failure");
12458 expect(v[99] == 1501) catch @panic("test failure");
12459 expect(v[100] == 1502) catch @panic("test failure");
12460 expect(v[101] == 1503) catch @panic("test failure");
12461 expect(v[102] == 1504) catch @panic("test failure");
12462 expect(v[103] == 1505) catch @panic("test failure");
12463 expect(v[104] == 1506) catch @panic("test failure");
12464 expect(v[105] == 1507) catch @panic("test failure");
12465 expect(v[106] == 1508) catch @panic("test failure");
12466 expect(v[107] == 1509) catch @panic("test failure");
12467 expect(v[108] == 1510) catch @panic("test failure");
12468 expect(v[109] == 1511) catch @panic("test failure");
12469 expect(v[110] == 1512) catch @panic("test failure");
12470 expect(v[111] == 1513) catch @panic("test failure");
12471 expect(v[112] == 1514) catch @panic("test failure");
12472 expect(v[113] == 1515) catch @panic("test failure");
12473 expect(v[114] == 1516) catch @panic("test failure");
12474 expect(v[115] == 1517) catch @panic("test failure");
12475 expect(v[116] == 1518) catch @panic("test failure");
12476 expect(v[117] == 1519) catch @panic("test failure");
12477 expect(v[118] == 1520) catch @panic("test failure");
12478 expect(v[119] == 1521) catch @panic("test failure");
12479 expect(v[120] == 1522) catch @panic("test failure");
12480 expect(v[121] == 1523) catch @panic("test failure");
12481 expect(v[122] == 1524) catch @panic("test failure");
12482 expect(v[123] == 1525) catch @panic("test failure");
12483 expect(v[124] == 1526) catch @panic("test failure");
12484 expect(v[125] == 1527) catch @panic("test failure");
12485 expect(v[126] == 1528) catch @panic("test failure");
12486 expect(v[127] == 1529) catch @panic("test failure");
12487 expect(i == 128) catch @panic("test failure");
12488}
12489
12490extern fn c_ret_vector_128_u32() @Vector(128, u32);
12491extern fn c_vector_128_u32(@Vector(128, u32), usize) void;
12492extern fn c_test_vector_128_u32() void;
12493
12494test "@Vector(128, u32)" {
12495 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12496 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12497 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
12498 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12499
12500 const v = c_ret_vector_128_u32();
12501 try expect(v[0] == 1530);
12502 try expect(v[1] == 1531);
12503 try expect(v[2] == 1532);
12504 try expect(v[3] == 1533);
12505 try expect(v[4] == 1534);
12506 try expect(v[5] == 1535);
12507 try expect(v[6] == 1536);
12508 try expect(v[7] == 1537);
12509 try expect(v[8] == 1538);
12510 try expect(v[9] == 1539);
12511 try expect(v[10] == 1540);
12512 try expect(v[11] == 1541);
12513 try expect(v[12] == 1542);
12514 try expect(v[13] == 1543);
12515 try expect(v[14] == 1544);
12516 try expect(v[15] == 1545);
12517 try expect(v[16] == 1546);
12518 try expect(v[17] == 1547);
12519 try expect(v[18] == 1548);
12520 try expect(v[19] == 1549);
12521 try expect(v[20] == 1550);
12522 try expect(v[21] == 1551);
12523 try expect(v[22] == 1552);
12524 try expect(v[23] == 1553);
12525 try expect(v[24] == 1554);
12526 try expect(v[25] == 1555);
12527 try expect(v[26] == 1556);
12528 try expect(v[27] == 1557);
12529 try expect(v[28] == 1558);
12530 try expect(v[29] == 1559);
12531 try expect(v[30] == 1560);
12532 try expect(v[31] == 1561);
12533 try expect(v[32] == 1562);
12534 try expect(v[33] == 1563);
12535 try expect(v[34] == 1564);
12536 try expect(v[35] == 1565);
12537 try expect(v[36] == 1566);
12538 try expect(v[37] == 1567);
12539 try expect(v[38] == 1568);
12540 try expect(v[39] == 1569);
12541 try expect(v[40] == 1570);
12542 try expect(v[41] == 1571);
12543 try expect(v[42] == 1572);
12544 try expect(v[43] == 1573);
12545 try expect(v[44] == 1574);
12546 try expect(v[45] == 1575);
12547 try expect(v[46] == 1576);
12548 try expect(v[47] == 1577);
12549 try expect(v[48] == 1578);
12550 try expect(v[49] == 1579);
12551 try expect(v[50] == 1580);
12552 try expect(v[51] == 1581);
12553 try expect(v[52] == 1582);
12554 try expect(v[53] == 1583);
12555 try expect(v[54] == 1584);
12556 try expect(v[55] == 1585);
12557 try expect(v[56] == 1586);
12558 try expect(v[57] == 1587);
12559 try expect(v[58] == 1588);
12560 try expect(v[59] == 1589);
12561 try expect(v[60] == 1590);
12562 try expect(v[61] == 1591);
12563 try expect(v[62] == 1592);
12564 try expect(v[63] == 1593);
12565 try expect(v[64] == 1594);
12566 try expect(v[65] == 1595);
12567 try expect(v[66] == 1596);
12568 try expect(v[67] == 1597);
12569 try expect(v[68] == 1598);
12570 try expect(v[69] == 1599);
12571 try expect(v[70] == 1600);
12572 try expect(v[71] == 1601);
12573 try expect(v[72] == 1602);
12574 try expect(v[73] == 1603);
12575 try expect(v[74] == 1604);
12576 try expect(v[75] == 1605);
12577 try expect(v[76] == 1606);
12578 try expect(v[77] == 1607);
12579 try expect(v[78] == 1608);
12580 try expect(v[79] == 1609);
12581 try expect(v[80] == 1610);
12582 try expect(v[81] == 1611);
12583 try expect(v[82] == 1612);
12584 try expect(v[83] == 1613);
12585 try expect(v[84] == 1614);
12586 try expect(v[85] == 1615);
12587 try expect(v[86] == 1616);
12588 try expect(v[87] == 1617);
12589 try expect(v[88] == 1618);
12590 try expect(v[89] == 1619);
12591 try expect(v[90] == 1620);
12592 try expect(v[91] == 1621);
12593 try expect(v[92] == 1622);
12594 try expect(v[93] == 1623);
12595 try expect(v[94] == 1624);
12596 try expect(v[95] == 1625);
12597 try expect(v[96] == 1626);
12598 try expect(v[97] == 1627);
12599 try expect(v[98] == 1628);
12600 try expect(v[99] == 1629);
12601 try expect(v[100] == 1630);
12602 try expect(v[101] == 1631);
12603 try expect(v[102] == 1632);
12604 try expect(v[103] == 1633);
12605 try expect(v[104] == 1634);
12606 try expect(v[105] == 1635);
12607 try expect(v[106] == 1636);
12608 try expect(v[107] == 1637);
12609 try expect(v[108] == 1638);
12610 try expect(v[109] == 1639);
12611 try expect(v[110] == 1640);
12612 try expect(v[111] == 1641);
12613 try expect(v[112] == 1642);
12614 try expect(v[113] == 1643);
12615 try expect(v[114] == 1644);
12616 try expect(v[115] == 1645);
12617 try expect(v[116] == 1646);
12618 try expect(v[117] == 1647);
12619 try expect(v[118] == 1648);
12620 try expect(v[119] == 1649);
12621 try expect(v[120] == 1650);
12622 try expect(v[121] == 1651);
12623 try expect(v[122] == 1652);
12624 try expect(v[123] == 1653);
12625 try expect(v[124] == 1654);
12626 try expect(v[125] == 1655);
12627 try expect(v[126] == 1656);
12628 try expect(v[127] == 1657);
12629 c_vector_128_u32(.{
12630 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
12631 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
12632 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
12633 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
12634 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
12635 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
12636 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
12637 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
12638 }, 128);
12639 c_test_vector_128_u32();
12640}
12641
12642export fn zig_ret_vector_1_u64() @Vector(1, u64) {
12643 return .{1};
12644}
12645export fn zig_vector_1_u64(v: @Vector(1, u64), i: usize) void {
12646 expect(v[0] == 2) catch @panic("test failure");
12647 expect(i == 1) catch @panic("test failure");
12648}
12649
12650extern fn c_ret_vector_1_u64() @Vector(1, u64);
12651extern fn c_vector_1_u64(@Vector(1, u64), usize) void;
12652extern fn c_test_vector_1_u64() void;
12653
12654test "@Vector(1, u64)" {
12655 const v = c_ret_vector_1_u64();
12656 try expect(v[0] == 3);
12657 c_vector_1_u64(.{4}, 1);
12658 c_test_vector_1_u64();
12659}
12660
12661export fn zig_ret_vector_2_u64() @Vector(2, u64) {
12662 return .{ 5, 6 };
12663}
12664export fn zig_vector_2_u64(v: @Vector(2, u64), i: usize) void {
12665 expect(v[0] == 7) catch @panic("test failure");
12666 expect(v[1] == 8) catch @panic("test failure");
12667 expect(i == 2) catch @panic("test failure");
12668}
12669
12670extern fn c_ret_vector_2_u64() @Vector(2, u64);
12671extern fn c_vector_2_u64(@Vector(2, u64), usize) void;
12672extern fn c_test_vector_2_u64() void;
12673
12674test "@Vector(2, u64)" {
12675 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12676
12677 const v = c_ret_vector_2_u64();
12678 try expect(v[0] == 9);
12679 try expect(v[1] == 10);
12680 c_vector_2_u64(.{ 11, 12 }, 2);
12681 c_test_vector_2_u64();
12682}
12683
12684export fn zig_ret_vector_3_u64() @Vector(3, u64) {
12685 return .{ 13, 14, 15 };
12686}
12687export fn zig_vector_3_u64(v: @Vector(3, u64), i: usize) void {
12688 expect(v[0] == 16) catch @panic("test failure");
12689 expect(v[1] == 17) catch @panic("test failure");
12690 expect(v[2] == 18) catch @panic("test failure");
12691 expect(i == 3) catch @panic("test failure");
12692}
12693
12694extern fn c_ret_vector_3_u64() @Vector(3, u64);
12695extern fn c_vector_3_u64(@Vector(3, u64), usize) void;
12696extern fn c_test_vector_3_u64() void;
12697
12698test "@Vector(3, u64)" {
12699 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12700 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12701 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
12702 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12703
12704 const v = c_ret_vector_3_u64();
12705 try expect(v[0] == 19);
12706 try expect(v[1] == 20);
12707 try expect(v[2] == 21);
12708 c_vector_3_u64(.{ 22, 23, 24 }, 3);
12709 c_test_vector_3_u64();
12710}
12711
12712export fn zig_ret_vector_4_u64() @Vector(4, u64) {
12713 return .{ 25, 26, 27, 28 };
12714}
12715export fn zig_vector_4_u64(v: @Vector(4, u64), i: usize) void {
12716 expect(v[0] == 29) catch @panic("test failure");
12717 expect(v[1] == 30) catch @panic("test failure");
12718 expect(v[2] == 31) catch @panic("test failure");
12719 expect(v[3] == 32) catch @panic("test failure");
12720 expect(i == 4) catch @panic("test failure");
12721}
12722
12723extern fn c_ret_vector_4_u64() @Vector(4, u64);
12724extern fn c_vector_4_u64(@Vector(4, u64), usize) void;
12725extern fn c_test_vector_4_u64() void;
12726
12727test "@Vector(4, u64)" {
12728 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12729 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12730 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12731
12732 const v = c_ret_vector_4_u64();
12733 try expect(v[0] == 33);
12734 try expect(v[1] == 34);
12735 try expect(v[2] == 35);
12736 try expect(v[3] == 36);
12737 c_vector_4_u64(.{ 37, 38, 39, 40 }, 4);
12738 c_test_vector_4_u64();
12739}
12740
12741export fn zig_ret_vector_6_u64() @Vector(6, u64) {
12742 return .{ 41, 42, 43, 44, 45, 46 };
12743}
12744export fn zig_vector_6_u64(v: @Vector(6, u64), i: usize) void {
12745 expect(v[0] == 47) catch @panic("test failure");
12746 expect(v[1] == 48) catch @panic("test failure");
12747 expect(v[2] == 49) catch @panic("test failure");
12748 expect(v[3] == 50) catch @panic("test failure");
12749 expect(v[4] == 51) catch @panic("test failure");
12750 expect(v[5] == 52) catch @panic("test failure");
12751 expect(i == 6) catch @panic("test failure");
12752}
12753
12754extern fn c_ret_vector_6_u64() @Vector(6, u64);
12755extern fn c_vector_6_u64(@Vector(6, u64), usize) void;
12756extern fn c_test_vector_6_u64() void;
12757
12758test "@Vector(6, u64)" {
12759 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12760 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
12761 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12762
12763 const v = c_ret_vector_6_u64();
12764 try expect(v[0] == 53);
12765 try expect(v[1] == 54);
12766 try expect(v[2] == 55);
12767 try expect(v[3] == 56);
12768 try expect(v[4] == 57);
12769 try expect(v[5] == 58);
12770 c_vector_6_u64(.{ 59, 60, 61, 62, 63, 64 }, 6);
12771 c_test_vector_6_u64();
12772}
12773
12774export fn zig_ret_vector_8_u64() @Vector(8, u64) {
12775 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
12776}
12777export fn zig_vector_8_u64(v: @Vector(8, u64), i: usize) void {
12778 expect(v[0] == 73) catch @panic("test failure");
12779 expect(v[1] == 74) catch @panic("test failure");
12780 expect(v[2] == 75) catch @panic("test failure");
12781 expect(v[3] == 76) catch @panic("test failure");
12782 expect(v[4] == 77) catch @panic("test failure");
12783 expect(v[5] == 78) catch @panic("test failure");
12784 expect(v[6] == 79) catch @panic("test failure");
12785 expect(v[7] == 80) catch @panic("test failure");
12786 expect(i == 8) catch @panic("test failure");
12787}
12788
12789extern fn c_ret_vector_8_u64() @Vector(8, u64);
12790extern fn c_vector_8_u64(@Vector(8, u64), usize) void;
12791extern fn c_test_vector_8_u64() void;
12792
12793test "@Vector(8, u64)" {
12794 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12795 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12796 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12797
12798 const v = c_ret_vector_8_u64();
12799 try expect(v[0] == 81);
12800 try expect(v[1] == 82);
12801 try expect(v[2] == 83);
12802 try expect(v[3] == 84);
12803 try expect(v[4] == 85);
12804 try expect(v[5] == 86);
12805 try expect(v[6] == 87);
12806 try expect(v[7] == 88);
12807 c_vector_8_u64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
12808 c_test_vector_8_u64();
12809}
12810
12811export fn zig_ret_vector_12_u64() @Vector(12, u64) {
12812 return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
12813}
12814export fn zig_vector_12_u64(v: @Vector(12, u64), i: usize) void {
12815 expect(v[0] == 109) catch @panic("test failure");
12816 expect(v[1] == 110) catch @panic("test failure");
12817 expect(v[2] == 111) catch @panic("test failure");
12818 expect(v[3] == 112) catch @panic("test failure");
12819 expect(v[4] == 113) catch @panic("test failure");
12820 expect(v[5] == 114) catch @panic("test failure");
12821 expect(v[6] == 115) catch @panic("test failure");
12822 expect(v[7] == 116) catch @panic("test failure");
12823 expect(v[8] == 117) catch @panic("test failure");
12824 expect(v[9] == 118) catch @panic("test failure");
12825 expect(v[10] == 119) catch @panic("test failure");
12826 expect(v[11] == 120) catch @panic("test failure");
12827 expect(i == 12) catch @panic("test failure");
12828}
12829
12830extern fn c_ret_vector_12_u64() @Vector(12, u64);
12831extern fn c_vector_12_u64(@Vector(12, u64), usize) void;
12832extern fn c_test_vector_12_u64() void;
12833
12834test "@Vector(12, u64)" {
12835 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12836 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
12837 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12838
12839 const v = c_ret_vector_12_u64();
12840 try expect(v[0] == 121);
12841 try expect(v[1] == 122);
12842 try expect(v[2] == 123);
12843 try expect(v[3] == 124);
12844 try expect(v[4] == 125);
12845 try expect(v[5] == 126);
12846 try expect(v[6] == 127);
12847 try expect(v[7] == 128);
12848 try expect(v[8] == 129);
12849 try expect(v[9] == 130);
12850 try expect(v[10] == 131);
12851 try expect(v[11] == 132);
12852 c_vector_12_u64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
12853 c_test_vector_12_u64();
12854}
12855
12856export fn zig_ret_vector_16_u64() @Vector(16, u64) {
12857 return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
12858}
12859export fn zig_vector_16_u64(v: @Vector(16, u64), i: usize) void {
12860 expect(v[0] == 161) catch @panic("test failure");
12861 expect(v[1] == 162) catch @panic("test failure");
12862 expect(v[2] == 163) catch @panic("test failure");
12863 expect(v[3] == 164) catch @panic("test failure");
12864 expect(v[4] == 165) catch @panic("test failure");
12865 expect(v[5] == 166) catch @panic("test failure");
12866 expect(v[6] == 167) catch @panic("test failure");
12867 expect(v[7] == 168) catch @panic("test failure");
12868 expect(v[8] == 169) catch @panic("test failure");
12869 expect(v[9] == 170) catch @panic("test failure");
12870 expect(v[10] == 171) catch @panic("test failure");
12871 expect(v[11] == 172) catch @panic("test failure");
12872 expect(v[12] == 173) catch @panic("test failure");
12873 expect(v[13] == 174) catch @panic("test failure");
12874 expect(v[14] == 175) catch @panic("test failure");
12875 expect(v[15] == 176) catch @panic("test failure");
12876 expect(i == 16) catch @panic("test failure");
12877}
12878
12879extern fn c_ret_vector_16_u64() @Vector(16, u64);
12880extern fn c_vector_16_u64(@Vector(16, u64), usize) void;
12881extern fn c_test_vector_16_u64() void;
12882
12883test "@Vector(16, u64)" {
12884 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12885 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
12886 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
12887 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12888
12889 const v = c_ret_vector_16_u64();
12890 try expect(v[0] == 177);
12891 try expect(v[1] == 178);
12892 try expect(v[2] == 179);
12893 try expect(v[3] == 180);
12894 try expect(v[4] == 181);
12895 try expect(v[5] == 182);
12896 try expect(v[6] == 183);
12897 try expect(v[7] == 184);
12898 try expect(v[8] == 185);
12899 try expect(v[9] == 186);
12900 try expect(v[10] == 187);
12901 try expect(v[11] == 188);
12902 try expect(v[12] == 189);
12903 try expect(v[13] == 190);
12904 try expect(v[14] == 191);
12905 try expect(v[15] == 192);
12906 c_vector_16_u64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
12907 c_test_vector_16_u64();
12908}
12909
12910export fn zig_ret_vector_24_u64() @Vector(24, u64) {
12911 return .{
12912 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
12913 225, 226, 227, 228, 229, 230, 231, 232,
12914 };
12915}
12916export fn zig_vector_24_u64(v: @Vector(24, u64), i: usize) void {
12917 expect(v[0] == 233) catch @panic("test failure");
12918 expect(v[1] == 234) catch @panic("test failure");
12919 expect(v[2] == 235) catch @panic("test failure");
12920 expect(v[3] == 236) catch @panic("test failure");
12921 expect(v[4] == 237) catch @panic("test failure");
12922 expect(v[5] == 238) catch @panic("test failure");
12923 expect(v[6] == 239) catch @panic("test failure");
12924 expect(v[7] == 240) catch @panic("test failure");
12925 expect(v[8] == 241) catch @panic("test failure");
12926 expect(v[9] == 242) catch @panic("test failure");
12927 expect(v[10] == 243) catch @panic("test failure");
12928 expect(v[11] == 244) catch @panic("test failure");
12929 expect(v[12] == 245) catch @panic("test failure");
12930 expect(v[13] == 246) catch @panic("test failure");
12931 expect(v[14] == 247) catch @panic("test failure");
12932 expect(v[15] == 248) catch @panic("test failure");
12933 expect(v[16] == 249) catch @panic("test failure");
12934 expect(v[17] == 250) catch @panic("test failure");
12935 expect(v[18] == 251) catch @panic("test failure");
12936 expect(v[19] == 252) catch @panic("test failure");
12937 expect(v[20] == 253) catch @panic("test failure");
12938 expect(v[21] == 254) catch @panic("test failure");
12939 expect(v[22] == 255) catch @panic("test failure");
12940 expect(v[23] == 256) catch @panic("test failure");
12941 expect(i == 24) catch @panic("test failure");
12942}
12943
12944extern fn c_ret_vector_24_u64() @Vector(24, u64);
12945extern fn c_vector_24_u64(@Vector(24, u64), usize) void;
12946extern fn c_test_vector_24_u64() void;
12947
12948test "@Vector(24, u64)" {
12949 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
12950 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
12951 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
12952
12953 const v = c_ret_vector_24_u64();
12954 try expect(v[0] == 257);
12955 try expect(v[1] == 258);
12956 try expect(v[2] == 259);
12957 try expect(v[3] == 260);
12958 try expect(v[4] == 261);
12959 try expect(v[5] == 262);
12960 try expect(v[6] == 263);
12961 try expect(v[7] == 264);
12962 try expect(v[8] == 265);
12963 try expect(v[9] == 266);
12964 try expect(v[10] == 267);
12965 try expect(v[11] == 268);
12966 try expect(v[12] == 269);
12967 try expect(v[13] == 270);
12968 try expect(v[14] == 271);
12969 try expect(v[15] == 272);
12970 try expect(v[16] == 273);
12971 try expect(v[17] == 274);
12972 try expect(v[18] == 275);
12973 try expect(v[19] == 276);
12974 try expect(v[20] == 277);
12975 try expect(v[21] == 278);
12976 try expect(v[22] == 279);
12977 try expect(v[23] == 280);
12978 c_vector_24_u64(.{
12979 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
12980 297, 298, 299, 300, 301, 302, 303, 304,
12981 }, 24);
12982 c_test_vector_24_u64();
12983}
12984
12985export fn zig_ret_vector_32_u64() @Vector(32, u64) {
12986 return .{
12987 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
12988 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
12989 };
12990}
12991export fn zig_vector_32_u64(v: @Vector(32, u64), i: usize) void {
12992 expect(v[0] == 337) catch @panic("test failure");
12993 expect(v[1] == 338) catch @panic("test failure");
12994 expect(v[2] == 339) catch @panic("test failure");
12995 expect(v[3] == 340) catch @panic("test failure");
12996 expect(v[4] == 341) catch @panic("test failure");
12997 expect(v[5] == 342) catch @panic("test failure");
12998 expect(v[6] == 343) catch @panic("test failure");
12999 expect(v[7] == 344) catch @panic("test failure");
13000 expect(v[8] == 345) catch @panic("test failure");
13001 expect(v[9] == 346) catch @panic("test failure");
13002 expect(v[10] == 347) catch @panic("test failure");
13003 expect(v[11] == 348) catch @panic("test failure");
13004 expect(v[12] == 349) catch @panic("test failure");
13005 expect(v[13] == 350) catch @panic("test failure");
13006 expect(v[14] == 351) catch @panic("test failure");
13007 expect(v[15] == 352) catch @panic("test failure");
13008 expect(v[16] == 353) catch @panic("test failure");
13009 expect(v[17] == 354) catch @panic("test failure");
13010 expect(v[18] == 355) catch @panic("test failure");
13011 expect(v[19] == 356) catch @panic("test failure");
13012 expect(v[20] == 357) catch @panic("test failure");
13013 expect(v[21] == 358) catch @panic("test failure");
13014 expect(v[22] == 359) catch @panic("test failure");
13015 expect(v[23] == 360) catch @panic("test failure");
13016 expect(v[24] == 361) catch @panic("test failure");
13017 expect(v[25] == 362) catch @panic("test failure");
13018 expect(v[26] == 363) catch @panic("test failure");
13019 expect(v[27] == 364) catch @panic("test failure");
13020 expect(v[28] == 365) catch @panic("test failure");
13021 expect(v[29] == 366) catch @panic("test failure");
13022 expect(v[30] == 367) catch @panic("test failure");
13023 expect(v[31] == 368) catch @panic("test failure");
13024 expect(i == 32) catch @panic("test failure");
13025}
13026
13027extern fn c_ret_vector_32_u64() @Vector(32, u64);
13028extern fn c_vector_32_u64(@Vector(32, u64), usize) void;
13029extern fn c_test_vector_32_u64() void;
13030
13031test "@Vector(32, u64)" {
13032 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13033 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13034 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
13035 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13036
13037 const v = c_ret_vector_32_u64();
13038 try expect(v[0] == 369);
13039 try expect(v[1] == 370);
13040 try expect(v[2] == 371);
13041 try expect(v[3] == 372);
13042 try expect(v[4] == 373);
13043 try expect(v[5] == 374);
13044 try expect(v[6] == 375);
13045 try expect(v[7] == 376);
13046 try expect(v[8] == 377);
13047 try expect(v[9] == 378);
13048 try expect(v[10] == 379);
13049 try expect(v[11] == 380);
13050 try expect(v[12] == 381);
13051 try expect(v[13] == 382);
13052 try expect(v[14] == 383);
13053 try expect(v[15] == 384);
13054 try expect(v[16] == 385);
13055 try expect(v[17] == 386);
13056 try expect(v[18] == 387);
13057 try expect(v[19] == 388);
13058 try expect(v[20] == 389);
13059 try expect(v[21] == 390);
13060 try expect(v[22] == 391);
13061 try expect(v[23] == 392);
13062 try expect(v[24] == 393);
13063 try expect(v[25] == 394);
13064 try expect(v[26] == 395);
13065 try expect(v[27] == 396);
13066 try expect(v[28] == 397);
13067 try expect(v[29] == 398);
13068 try expect(v[30] == 399);
13069 try expect(v[31] == 400);
13070 c_vector_32_u64(.{
13071 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
13072 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
13073 }, 32);
13074 c_test_vector_32_u64();
13075}
13076
13077export fn zig_ret_vector_48_u64() @Vector(48, u64) {
13078 return .{
13079 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
13080 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
13081 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
13082 };
13083}
13084export fn zig_vector_48_u64(v: @Vector(48, u64), i: usize) void {
13085 expect(v[0] == 481) catch @panic("test failure");
13086 expect(v[1] == 482) catch @panic("test failure");
13087 expect(v[2] == 483) catch @panic("test failure");
13088 expect(v[3] == 484) catch @panic("test failure");
13089 expect(v[4] == 485) catch @panic("test failure");
13090 expect(v[5] == 486) catch @panic("test failure");
13091 expect(v[6] == 487) catch @panic("test failure");
13092 expect(v[7] == 488) catch @panic("test failure");
13093 expect(v[8] == 489) catch @panic("test failure");
13094 expect(v[9] == 490) catch @panic("test failure");
13095 expect(v[10] == 491) catch @panic("test failure");
13096 expect(v[11] == 492) catch @panic("test failure");
13097 expect(v[12] == 493) catch @panic("test failure");
13098 expect(v[13] == 494) catch @panic("test failure");
13099 expect(v[14] == 495) catch @panic("test failure");
13100 expect(v[15] == 496) catch @panic("test failure");
13101 expect(v[16] == 497) catch @panic("test failure");
13102 expect(v[17] == 498) catch @panic("test failure");
13103 expect(v[18] == 499) catch @panic("test failure");
13104 expect(v[19] == 500) catch @panic("test failure");
13105 expect(v[20] == 501) catch @panic("test failure");
13106 expect(v[21] == 502) catch @panic("test failure");
13107 expect(v[22] == 503) catch @panic("test failure");
13108 expect(v[23] == 504) catch @panic("test failure");
13109 expect(v[24] == 505) catch @panic("test failure");
13110 expect(v[25] == 506) catch @panic("test failure");
13111 expect(v[26] == 507) catch @panic("test failure");
13112 expect(v[27] == 508) catch @panic("test failure");
13113 expect(v[28] == 509) catch @panic("test failure");
13114 expect(v[29] == 510) catch @panic("test failure");
13115 expect(v[30] == 511) catch @panic("test failure");
13116 expect(v[31] == 512) catch @panic("test failure");
13117 expect(v[32] == 513) catch @panic("test failure");
13118 expect(v[33] == 514) catch @panic("test failure");
13119 expect(v[34] == 515) catch @panic("test failure");
13120 expect(v[35] == 516) catch @panic("test failure");
13121 expect(v[36] == 517) catch @panic("test failure");
13122 expect(v[37] == 518) catch @panic("test failure");
13123 expect(v[38] == 519) catch @panic("test failure");
13124 expect(v[39] == 520) catch @panic("test failure");
13125 expect(v[40] == 521) catch @panic("test failure");
13126 expect(v[41] == 522) catch @panic("test failure");
13127 expect(v[42] == 523) catch @panic("test failure");
13128 expect(v[43] == 524) catch @panic("test failure");
13129 expect(v[44] == 525) catch @panic("test failure");
13130 expect(v[45] == 526) catch @panic("test failure");
13131 expect(v[46] == 527) catch @panic("test failure");
13132 expect(v[47] == 528) catch @panic("test failure");
13133 expect(i == 48) catch @panic("test failure");
13134}
13135
13136extern fn c_ret_vector_48_u64() @Vector(48, u64);
13137extern fn c_vector_48_u64(@Vector(48, u64), usize) void;
13138extern fn c_test_vector_48_u64() void;
13139
13140test "@Vector(48, u64)" {
13141 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13142 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
13143 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13144
13145 const v = c_ret_vector_48_u64();
13146 try expect(v[0] == 529);
13147 try expect(v[1] == 530);
13148 try expect(v[2] == 531);
13149 try expect(v[3] == 532);
13150 try expect(v[4] == 533);
13151 try expect(v[5] == 534);
13152 try expect(v[6] == 535);
13153 try expect(v[7] == 536);
13154 try expect(v[8] == 537);
13155 try expect(v[9] == 538);
13156 try expect(v[10] == 539);
13157 try expect(v[11] == 540);
13158 try expect(v[12] == 541);
13159 try expect(v[13] == 542);
13160 try expect(v[14] == 543);
13161 try expect(v[15] == 544);
13162 try expect(v[16] == 545);
13163 try expect(v[17] == 546);
13164 try expect(v[18] == 547);
13165 try expect(v[19] == 548);
13166 try expect(v[20] == 549);
13167 try expect(v[21] == 550);
13168 try expect(v[22] == 551);
13169 try expect(v[23] == 552);
13170 try expect(v[24] == 553);
13171 try expect(v[25] == 554);
13172 try expect(v[26] == 555);
13173 try expect(v[27] == 556);
13174 try expect(v[28] == 557);
13175 try expect(v[29] == 558);
13176 try expect(v[30] == 559);
13177 try expect(v[31] == 560);
13178 try expect(v[32] == 561);
13179 try expect(v[33] == 562);
13180 try expect(v[34] == 563);
13181 try expect(v[35] == 564);
13182 try expect(v[36] == 565);
13183 try expect(v[37] == 566);
13184 try expect(v[38] == 567);
13185 try expect(v[39] == 568);
13186 try expect(v[40] == 569);
13187 try expect(v[41] == 570);
13188 try expect(v[42] == 571);
13189 try expect(v[43] == 572);
13190 try expect(v[44] == 573);
13191 try expect(v[45] == 574);
13192 try expect(v[46] == 575);
13193 try expect(v[47] == 576);
13194 c_vector_48_u64(.{
13195 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
13196 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
13197 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
13198 }, 48);
13199 c_test_vector_48_u64();
13200}
13201
13202export fn zig_ret_vector_64_u64() @Vector(64, u64) {
13203 return .{
13204 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
13205 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
13206 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
13207 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
13208 };
13209}
13210export fn zig_vector_64_u64(v: @Vector(64, u64), i: usize) void {
13211 expect(v[0] == 689) catch @panic("test failure");
13212 expect(v[1] == 690) catch @panic("test failure");
13213 expect(v[2] == 691) catch @panic("test failure");
13214 expect(v[3] == 692) catch @panic("test failure");
13215 expect(v[4] == 693) catch @panic("test failure");
13216 expect(v[5] == 694) catch @panic("test failure");
13217 expect(v[6] == 695) catch @panic("test failure");
13218 expect(v[7] == 696) catch @panic("test failure");
13219 expect(v[8] == 697) catch @panic("test failure");
13220 expect(v[9] == 698) catch @panic("test failure");
13221 expect(v[10] == 699) catch @panic("test failure");
13222 expect(v[11] == 700) catch @panic("test failure");
13223 expect(v[12] == 701) catch @panic("test failure");
13224 expect(v[13] == 702) catch @panic("test failure");
13225 expect(v[14] == 703) catch @panic("test failure");
13226 expect(v[15] == 704) catch @panic("test failure");
13227 expect(v[16] == 705) catch @panic("test failure");
13228 expect(v[17] == 706) catch @panic("test failure");
13229 expect(v[18] == 707) catch @panic("test failure");
13230 expect(v[19] == 708) catch @panic("test failure");
13231 expect(v[20] == 709) catch @panic("test failure");
13232 expect(v[21] == 710) catch @panic("test failure");
13233 expect(v[22] == 711) catch @panic("test failure");
13234 expect(v[23] == 712) catch @panic("test failure");
13235 expect(v[24] == 713) catch @panic("test failure");
13236 expect(v[25] == 714) catch @panic("test failure");
13237 expect(v[26] == 715) catch @panic("test failure");
13238 expect(v[27] == 716) catch @panic("test failure");
13239 expect(v[28] == 717) catch @panic("test failure");
13240 expect(v[29] == 718) catch @panic("test failure");
13241 expect(v[30] == 719) catch @panic("test failure");
13242 expect(v[31] == 720) catch @panic("test failure");
13243 expect(v[32] == 721) catch @panic("test failure");
13244 expect(v[33] == 722) catch @panic("test failure");
13245 expect(v[34] == 723) catch @panic("test failure");
13246 expect(v[35] == 724) catch @panic("test failure");
13247 expect(v[36] == 725) catch @panic("test failure");
13248 expect(v[37] == 726) catch @panic("test failure");
13249 expect(v[38] == 727) catch @panic("test failure");
13250 expect(v[39] == 728) catch @panic("test failure");
13251 expect(v[40] == 729) catch @panic("test failure");
13252 expect(v[41] == 730) catch @panic("test failure");
13253 expect(v[42] == 731) catch @panic("test failure");
13254 expect(v[43] == 732) catch @panic("test failure");
13255 expect(v[44] == 733) catch @panic("test failure");
13256 expect(v[45] == 734) catch @panic("test failure");
13257 expect(v[46] == 735) catch @panic("test failure");
13258 expect(v[47] == 736) catch @panic("test failure");
13259 expect(v[48] == 737) catch @panic("test failure");
13260 expect(v[49] == 738) catch @panic("test failure");
13261 expect(v[50] == 739) catch @panic("test failure");
13262 expect(v[51] == 740) catch @panic("test failure");
13263 expect(v[52] == 741) catch @panic("test failure");
13264 expect(v[53] == 742) catch @panic("test failure");
13265 expect(v[54] == 743) catch @panic("test failure");
13266 expect(v[55] == 744) catch @panic("test failure");
13267 expect(v[56] == 745) catch @panic("test failure");
13268 expect(v[57] == 746) catch @panic("test failure");
13269 expect(v[58] == 747) catch @panic("test failure");
13270 expect(v[59] == 748) catch @panic("test failure");
13271 expect(v[60] == 749) catch @panic("test failure");
13272 expect(v[61] == 750) catch @panic("test failure");
13273 expect(v[62] == 751) catch @panic("test failure");
13274 expect(v[63] == 752) catch @panic("test failure");
13275 expect(i == 64) catch @panic("test failure");
13276}
13277
13278extern fn c_ret_vector_64_u64() @Vector(64, u64);
13279extern fn c_vector_64_u64(@Vector(64, u64), usize) void;
13280extern fn c_test_vector_64_u64() void;
13281
13282test "@Vector(64, u64)" {
13283 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13284 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13285 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
13286 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13287
13288 const v = c_ret_vector_64_u64();
13289 try expect(v[0] == 753);
13290 try expect(v[1] == 754);
13291 try expect(v[2] == 755);
13292 try expect(v[3] == 756);
13293 try expect(v[4] == 757);
13294 try expect(v[5] == 758);
13295 try expect(v[6] == 759);
13296 try expect(v[7] == 760);
13297 try expect(v[8] == 761);
13298 try expect(v[9] == 762);
13299 try expect(v[10] == 763);
13300 try expect(v[11] == 764);
13301 try expect(v[12] == 765);
13302 try expect(v[13] == 766);
13303 try expect(v[14] == 767);
13304 try expect(v[15] == 768);
13305 try expect(v[16] == 769);
13306 try expect(v[17] == 770);
13307 try expect(v[18] == 771);
13308 try expect(v[19] == 772);
13309 try expect(v[20] == 773);
13310 try expect(v[21] == 774);
13311 try expect(v[22] == 775);
13312 try expect(v[23] == 776);
13313 try expect(v[24] == 777);
13314 try expect(v[25] == 778);
13315 try expect(v[26] == 779);
13316 try expect(v[27] == 780);
13317 try expect(v[28] == 781);
13318 try expect(v[29] == 782);
13319 try expect(v[30] == 783);
13320 try expect(v[31] == 784);
13321 try expect(v[32] == 785);
13322 try expect(v[33] == 786);
13323 try expect(v[34] == 787);
13324 try expect(v[35] == 788);
13325 try expect(v[36] == 789);
13326 try expect(v[37] == 790);
13327 try expect(v[38] == 791);
13328 try expect(v[39] == 792);
13329 try expect(v[40] == 793);
13330 try expect(v[41] == 794);
13331 try expect(v[42] == 795);
13332 try expect(v[43] == 796);
13333 try expect(v[44] == 797);
13334 try expect(v[45] == 798);
13335 try expect(v[46] == 799);
13336 try expect(v[47] == 800);
13337 try expect(v[48] == 801);
13338 try expect(v[49] == 802);
13339 try expect(v[50] == 803);
13340 try expect(v[51] == 804);
13341 try expect(v[52] == 805);
13342 try expect(v[53] == 806);
13343 try expect(v[54] == 807);
13344 try expect(v[55] == 808);
13345 try expect(v[56] == 809);
13346 try expect(v[57] == 810);
13347 try expect(v[58] == 811);
13348 try expect(v[59] == 812);
13349 try expect(v[60] == 813);
13350 try expect(v[61] == 814);
13351 try expect(v[62] == 815);
13352 try expect(v[63] == 816);
13353 c_vector_64_u64(.{
13354 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
13355 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
13356 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
13357 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
13358 }, 64);
13359 c_test_vector_64_u64();
13360}
13361
13362export fn zig_ret_vector_1_f32() @Vector(1, f32) {
13363 return .{1};
13364}
13365export fn zig_vector_1_f32(v: @Vector(1, f32), i: usize) void {
13366 expect(v[0] == 2) catch @panic("test failure");
13367 expect(i == 1) catch @panic("test failure");
13368}
13369
13370extern fn c_ret_vector_1_f32() @Vector(1, f32);
13371extern fn c_vector_1_f32(@Vector(1, f32), usize) void;
13372extern fn c_test_vector_1_f32() void;
13373
13374test "@Vector(1, f32)" {
13375 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
13376 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13377 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13378 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
13379 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13380
13381 const v = c_ret_vector_1_f32();
13382 try expect(v[0] == 3);
13383 c_vector_1_f32(.{4}, 1);
13384 c_test_vector_1_f32();
13385}
13386
13387export fn zig_ret_vector_2_f32() @Vector(2, f32) {
13388 return .{ 5, 6 };
13389}
13390export fn zig_vector_2_f32(v: @Vector(2, f32), i: usize) void {
13391 expect(v[0] == 7) catch @panic("test failure");
13392 expect(v[1] == 8) catch @panic("test failure");
13393 expect(i == 2) catch @panic("test failure");
13394}
13395
13396extern fn c_ret_vector_2_f32() @Vector(2, f32);
13397extern fn c_vector_2_f32(@Vector(2, f32), usize) void;
13398extern fn c_test_vector_2_f32() void;
13399
13400test "@Vector(2, f32)" {
13401 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13402 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13403 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
13404
13405 const v = c_ret_vector_2_f32();
13406 try expect(v[0] == 9);
13407 try expect(v[1] == 10);
13408 c_vector_2_f32(.{ 11, 12 }, 2);
13409 c_test_vector_2_f32();
13410}
13411
13412export fn zig_ret_vector_3_f32() @Vector(3, f32) {
13413 return .{ 13, 14, 15 };
13414}
13415export fn zig_vector_3_f32(v: @Vector(3, f32), i: usize) void {
13416 expect(v[0] == 16) catch @panic("test failure");
13417 expect(v[1] == 17) catch @panic("test failure");
13418 expect(v[2] == 18) catch @panic("test failure");
13419 expect(i == 3) catch @panic("test failure");
13420}
13421
13422extern fn c_ret_vector_3_f32() @Vector(3, f32);
13423extern fn c_vector_3_f32(@Vector(3, f32), usize) void;
13424extern fn c_test_vector_3_f32() void;
13425
13426test "@Vector(3, f32)" {
13427 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
13428 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13429 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
13430
13431 const v = c_ret_vector_3_f32();
13432 try expect(v[0] == 19);
13433 try expect(v[1] == 20);
13434 try expect(v[2] == 21);
13435 c_vector_3_f32(.{ 22, 23, 24 }, 32);
13436 c_test_vector_3_f32();
13437}
13438
13439export fn zig_ret_vector_4_f32() @Vector(4, f32) {
13440 return .{ 25, 26, 27, 28 };
13441}
13442export fn zig_vector_4_f32(v: @Vector(4, f32), i: usize) void {
13443 expect(v[0] == 29) catch @panic("test failure");
13444 expect(v[1] == 30) catch @panic("test failure");
13445 expect(v[2] == 31) catch @panic("test failure");
13446 expect(v[3] == 32) catch @panic("test failure");
13447 expect(i == 4) catch @panic("test failure");
13448}
13449export fn zig_vector_4_f32_vector_4_f32(v0: @Vector(4, f32), v1: @Vector(4, f32), i: usize) void {
13450 expect(v0[0] == 33) catch @panic("test failure");
13451 expect(v0[1] == 34) catch @panic("test failure");
13452 expect(v0[2] == 35) catch @panic("test failure");
13453 expect(v0[3] == 36) catch @panic("test failure");
13454 expect(v1[0] == 37) catch @panic("test failure");
13455 expect(v1[1] == 38) catch @panic("test failure");
13456 expect(v1[2] == 39) catch @panic("test failure");
13457 expect(v1[3] == 40) catch @panic("test failure");
13458 expect(i == 8) catch @panic("test failure");
13459}
13460extern fn c_ret_vector_4_f32() @Vector(4, f32);
13461
13462extern fn c_vector_4_f32(@Vector(4, f32), usize) void;
13463extern fn c_vector_4_f32_vector_4_f32(@Vector(4, f32), @Vector(4, f32), usize) void;
13464extern fn c_test_vector_4_f32() void;
13465
13466test "@Vector(4, f32)" {
13467 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13468
13469 const v = c_ret_vector_4_f32();
13470 try expect(v[0] == 41);
13471 try expect(v[1] == 42);
13472 try expect(v[2] == 43);
13473 try expect(v[3] == 44);
13474 c_vector_4_f32(.{ 45, 46, 47, 48 }, 4);
13475 c_vector_4_f32_vector_4_f32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
13476 c_test_vector_4_f32();
13477}
13478
13479export fn zig_ret_vector_6_f32() @Vector(6, f32) {
13480 return .{ 41, 42, 43, 44, 45, 46 };
13481}
13482export fn zig_vector_6_f32(v: @Vector(6, f32), i: usize) void {
13483 expect(v[0] == 47) catch @panic("test failure");
13484 expect(v[1] == 48) catch @panic("test failure");
13485 expect(v[2] == 49) catch @panic("test failure");
13486 expect(v[3] == 50) catch @panic("test failure");
13487 expect(v[4] == 51) catch @panic("test failure");
13488 expect(v[5] == 52) catch @panic("test failure");
13489 expect(i == 6) catch @panic("test failure");
13490}
13491
13492extern fn c_ret_vector_6_f32() @Vector(6, f32);
13493extern fn c_vector_6_f32(@Vector(6, f32), usize) void;
13494extern fn c_test_vector_6_f32() void;
13495
13496test "@Vector(6, f32)" {
13497 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13498 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13499 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
13500 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13501
13502 const v = c_ret_vector_6_f32();
13503 try expect(v[0] == 53);
13504 try expect(v[1] == 54);
13505 try expect(v[2] == 55);
13506 try expect(v[3] == 56);
13507 try expect(v[4] == 57);
13508 try expect(v[5] == 58);
13509 c_vector_6_f32(.{ 59, 60, 61, 62, 63, 64 }, 6);
13510 c_test_vector_6_f32();
13511}
13512
13513export fn zig_ret_vector_8_f32() @Vector(8, f32) {
13514 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
13515}
13516export fn zig_vector_8_f32(v: @Vector(8, f32), i: usize) void {
13517 expect(v[0] == 73) catch @panic("test failure");
13518 expect(v[1] == 74) catch @panic("test failure");
13519 expect(v[2] == 75) catch @panic("test failure");
13520 expect(v[3] == 76) catch @panic("test failure");
13521 expect(v[4] == 77) catch @panic("test failure");
13522 expect(v[5] == 78) catch @panic("test failure");
13523 expect(v[6] == 79) catch @panic("test failure");
13524 expect(v[7] == 80) catch @panic("test failure");
13525 expect(i == 8) catch @panic("test failure");
13526}
13527
13528extern fn c_ret_vector_8_f32() @Vector(8, f32);
13529extern fn c_vector_8_f32(@Vector(8, f32), usize) void;
13530extern fn c_test_vector_8_f32() void;
13531
13532test "@Vector(8, f32)" {
13533 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13534 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13535 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
13536 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13537
13538 const v = c_ret_vector_8_f32();
13539 try expect(v[0] == 81);
13540 try expect(v[1] == 82);
13541 try expect(v[2] == 83);
13542 try expect(v[3] == 84);
13543 try expect(v[4] == 85);
13544 try expect(v[5] == 86);
13545 try expect(v[6] == 87);
13546 try expect(v[7] == 88);
13547 c_vector_8_f32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
13548 c_test_vector_8_f32();
13549}
13550
13551export fn zig_ret_vector_12_f32() @Vector(12, f32) {
13552 return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
13553}
13554export fn zig_vector_12_f32(v: @Vector(12, f32), i: usize) void {
13555 expect(v[0] == 109) catch @panic("test failure");
13556 expect(v[1] == 110) catch @panic("test failure");
13557 expect(v[2] == 111) catch @panic("test failure");
13558 expect(v[3] == 112) catch @panic("test failure");
13559 expect(v[4] == 113) catch @panic("test failure");
13560 expect(v[5] == 114) catch @panic("test failure");
13561 expect(v[6] == 115) catch @panic("test failure");
13562 expect(v[7] == 116) catch @panic("test failure");
13563 expect(v[8] == 117) catch @panic("test failure");
13564 expect(v[9] == 118) catch @panic("test failure");
13565 expect(v[10] == 119) catch @panic("test failure");
13566 expect(v[11] == 120) catch @panic("test failure");
13567 expect(i == 12) catch @panic("test failure");
13568}
13569
13570extern fn c_ret_vector_12_f32() @Vector(12, f32);
13571extern fn c_vector_12_f32(@Vector(12, f32), usize) void;
13572extern fn c_test_vector_12_f32() void;
13573
13574test "@Vector(12, f32)" {
13575 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13576 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13577 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
13578 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13579
13580 const v = c_ret_vector_12_f32();
13581 try expect(v[0] == 121);
13582 try expect(v[1] == 122);
13583 try expect(v[2] == 123);
13584 try expect(v[3] == 124);
13585 try expect(v[4] == 125);
13586 try expect(v[5] == 126);
13587 try expect(v[6] == 127);
13588 try expect(v[7] == 128);
13589 try expect(v[8] == 129);
13590 try expect(v[9] == 130);
13591 try expect(v[10] == 131);
13592 try expect(v[11] == 132);
13593 c_vector_12_f32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
13594 c_test_vector_12_f32();
13595}
13596
13597export fn zig_ret_vector_16_f32() @Vector(16, f32) {
13598 return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
13599}
13600export fn zig_vector_16_f32(v: @Vector(16, f32), i: usize) void {
13601 expect(v[0] == 161) catch @panic("test failure");
13602 expect(v[1] == 162) catch @panic("test failure");
13603 expect(v[2] == 163) catch @panic("test failure");
13604 expect(v[3] == 164) catch @panic("test failure");
13605 expect(v[4] == 165) catch @panic("test failure");
13606 expect(v[5] == 166) catch @panic("test failure");
13607 expect(v[6] == 167) catch @panic("test failure");
13608 expect(v[7] == 168) catch @panic("test failure");
13609 expect(v[8] == 169) catch @panic("test failure");
13610 expect(v[9] == 170) catch @panic("test failure");
13611 expect(v[10] == 171) catch @panic("test failure");
13612 expect(v[11] == 172) catch @panic("test failure");
13613 expect(v[12] == 173) catch @panic("test failure");
13614 expect(v[13] == 174) catch @panic("test failure");
13615 expect(v[14] == 175) catch @panic("test failure");
13616 expect(v[15] == 176) catch @panic("test failure");
13617 expect(i == 16) catch @panic("test failure");
13618}
13619
13620extern fn c_ret_vector_16_f32() @Vector(16, f32);
13621extern fn c_vector_16_f32(@Vector(16, f32), usize) void;
13622extern fn c_test_vector_16_f32() void;
13623
13624test "@Vector(16, f32)" {
13625 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13626 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13627 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
13628 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13629
13630 const v = c_ret_vector_16_f32();
13631 try expect(v[0] == 177);
13632 try expect(v[1] == 178);
13633 try expect(v[2] == 179);
13634 try expect(v[3] == 180);
13635 try expect(v[4] == 181);
13636 try expect(v[5] == 182);
13637 try expect(v[6] == 183);
13638 try expect(v[7] == 184);
13639 try expect(v[8] == 185);
13640 try expect(v[9] == 186);
13641 try expect(v[10] == 187);
13642 try expect(v[11] == 188);
13643 try expect(v[12] == 189);
13644 try expect(v[13] == 190);
13645 try expect(v[14] == 191);
13646 try expect(v[15] == 192);
13647 c_vector_16_f32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
13648 c_test_vector_16_f32();
13649}
13650
13651export fn zig_ret_vector_24_f32() @Vector(24, f32) {
13652 return .{
13653 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
13654 225, 226, 227, 228, 229, 230, 231, 232,
13655 };
13656}
13657export fn zig_vector_24_f32(v: @Vector(24, f32), i: usize) void {
13658 expect(v[0] == 233) catch @panic("test failure");
13659 expect(v[1] == 234) catch @panic("test failure");
13660 expect(v[2] == 235) catch @panic("test failure");
13661 expect(v[3] == 236) catch @panic("test failure");
13662 expect(v[4] == 237) catch @panic("test failure");
13663 expect(v[5] == 238) catch @panic("test failure");
13664 expect(v[6] == 239) catch @panic("test failure");
13665 expect(v[7] == 240) catch @panic("test failure");
13666 expect(v[8] == 241) catch @panic("test failure");
13667 expect(v[9] == 242) catch @panic("test failure");
13668 expect(v[10] == 243) catch @panic("test failure");
13669 expect(v[11] == 244) catch @panic("test failure");
13670 expect(v[12] == 245) catch @panic("test failure");
13671 expect(v[13] == 246) catch @panic("test failure");
13672 expect(v[14] == 247) catch @panic("test failure");
13673 expect(v[15] == 248) catch @panic("test failure");
13674 expect(v[16] == 249) catch @panic("test failure");
13675 expect(v[17] == 250) catch @panic("test failure");
13676 expect(v[18] == 251) catch @panic("test failure");
13677 expect(v[19] == 252) catch @panic("test failure");
13678 expect(v[20] == 253) catch @panic("test failure");
13679 expect(v[21] == 254) catch @panic("test failure");
13680 expect(v[22] == 255) catch @panic("test failure");
13681 expect(v[23] == 256) catch @panic("test failure");
13682 expect(i == 24) catch @panic("test failure");
13683}
13684
13685extern fn c_ret_vector_24_f32() @Vector(24, f32);
13686extern fn c_vector_24_f32(@Vector(24, f32), usize) void;
13687extern fn c_test_vector_24_f32() void;
13688
13689test "@Vector(24, f32)" {
13690 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13691 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13692 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
13693 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13694
13695 const v = c_ret_vector_24_f32();
13696 try expect(v[0] == 257);
13697 try expect(v[1] == 258);
13698 try expect(v[2] == 259);
13699 try expect(v[3] == 260);
13700 try expect(v[4] == 261);
13701 try expect(v[5] == 262);
13702 try expect(v[6] == 263);
13703 try expect(v[7] == 264);
13704 try expect(v[8] == 265);
13705 try expect(v[9] == 266);
13706 try expect(v[10] == 267);
13707 try expect(v[11] == 268);
13708 try expect(v[12] == 269);
13709 try expect(v[13] == 270);
13710 try expect(v[14] == 271);
13711 try expect(v[15] == 272);
13712 try expect(v[16] == 273);
13713 try expect(v[17] == 274);
13714 try expect(v[18] == 275);
13715 try expect(v[19] == 276);
13716 try expect(v[20] == 277);
13717 try expect(v[21] == 278);
13718 try expect(v[22] == 279);
13719 try expect(v[23] == 280);
13720 c_vector_24_f32(.{
13721 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
13722 297, 298, 299, 300, 301, 302, 303, 304,
13723 }, 24);
13724 c_test_vector_24_f32();
13725}
13726
13727export fn zig_ret_vector_32_f32() @Vector(32, f32) {
13728 return .{
13729 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
13730 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
13731 };
13732}
13733export fn zig_vector_32_f32(v: @Vector(32, f32), i: usize) void {
13734 expect(v[0] == 337) catch @panic("test failure");
13735 expect(v[1] == 338) catch @panic("test failure");
13736 expect(v[2] == 339) catch @panic("test failure");
13737 expect(v[3] == 340) catch @panic("test failure");
13738 expect(v[4] == 341) catch @panic("test failure");
13739 expect(v[5] == 342) catch @panic("test failure");
13740 expect(v[6] == 343) catch @panic("test failure");
13741 expect(v[7] == 344) catch @panic("test failure");
13742 expect(v[8] == 345) catch @panic("test failure");
13743 expect(v[9] == 346) catch @panic("test failure");
13744 expect(v[10] == 347) catch @panic("test failure");
13745 expect(v[11] == 348) catch @panic("test failure");
13746 expect(v[12] == 349) catch @panic("test failure");
13747 expect(v[13] == 350) catch @panic("test failure");
13748 expect(v[14] == 351) catch @panic("test failure");
13749 expect(v[15] == 352) catch @panic("test failure");
13750 expect(v[16] == 353) catch @panic("test failure");
13751 expect(v[17] == 354) catch @panic("test failure");
13752 expect(v[18] == 355) catch @panic("test failure");
13753 expect(v[19] == 356) catch @panic("test failure");
13754 expect(v[20] == 357) catch @panic("test failure");
13755 expect(v[21] == 358) catch @panic("test failure");
13756 expect(v[22] == 359) catch @panic("test failure");
13757 expect(v[23] == 360) catch @panic("test failure");
13758 expect(v[24] == 361) catch @panic("test failure");
13759 expect(v[25] == 362) catch @panic("test failure");
13760 expect(v[26] == 363) catch @panic("test failure");
13761 expect(v[27] == 364) catch @panic("test failure");
13762 expect(v[28] == 365) catch @panic("test failure");
13763 expect(v[29] == 366) catch @panic("test failure");
13764 expect(v[30] == 367) catch @panic("test failure");
13765 expect(v[31] == 368) catch @panic("test failure");
13766 expect(i == 32) catch @panic("test failure");
13767}
13768
13769extern fn c_ret_vector_32_f32() @Vector(32, f32);
13770extern fn c_vector_32_f32(@Vector(32, f32), usize) void;
13771extern fn c_test_vector_32_f32() void;
13772
13773test "@Vector(32, f32)" {
13774 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13775 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13776 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
13777 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13778
13779 const v = c_ret_vector_32_f32();
13780 try expect(v[0] == 369);
13781 try expect(v[1] == 370);
13782 try expect(v[2] == 371);
13783 try expect(v[3] == 372);
13784 try expect(v[4] == 373);
13785 try expect(v[5] == 374);
13786 try expect(v[6] == 375);
13787 try expect(v[7] == 376);
13788 try expect(v[8] == 377);
13789 try expect(v[9] == 378);
13790 try expect(v[10] == 379);
13791 try expect(v[11] == 380);
13792 try expect(v[12] == 381);
13793 try expect(v[13] == 382);
13794 try expect(v[14] == 383);
13795 try expect(v[15] == 384);
13796 try expect(v[16] == 385);
13797 try expect(v[17] == 386);
13798 try expect(v[18] == 387);
13799 try expect(v[19] == 388);
13800 try expect(v[20] == 389);
13801 try expect(v[21] == 390);
13802 try expect(v[22] == 391);
13803 try expect(v[23] == 392);
13804 try expect(v[24] == 393);
13805 try expect(v[25] == 394);
13806 try expect(v[26] == 395);
13807 try expect(v[27] == 396);
13808 try expect(v[28] == 397);
13809 try expect(v[29] == 398);
13810 try expect(v[30] == 399);
13811 try expect(v[31] == 400);
13812 c_vector_32_f32(.{
13813 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
13814 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
13815 }, 32);
13816 c_test_vector_32_f32();
13817}
13818
13819export fn zig_ret_vector_48_f32() @Vector(48, f32) {
13820 return .{
13821 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
13822 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
13823 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
13824 };
13825}
13826export fn zig_vector_48_f32(v: @Vector(48, f32), i: usize) void {
13827 expect(v[0] == 481) catch @panic("test failure");
13828 expect(v[1] == 482) catch @panic("test failure");
13829 expect(v[2] == 483) catch @panic("test failure");
13830 expect(v[3] == 484) catch @panic("test failure");
13831 expect(v[4] == 485) catch @panic("test failure");
13832 expect(v[5] == 486) catch @panic("test failure");
13833 expect(v[6] == 487) catch @panic("test failure");
13834 expect(v[7] == 488) catch @panic("test failure");
13835 expect(v[8] == 489) catch @panic("test failure");
13836 expect(v[9] == 490) catch @panic("test failure");
13837 expect(v[10] == 491) catch @panic("test failure");
13838 expect(v[11] == 492) catch @panic("test failure");
13839 expect(v[12] == 493) catch @panic("test failure");
13840 expect(v[13] == 494) catch @panic("test failure");
13841 expect(v[14] == 495) catch @panic("test failure");
13842 expect(v[15] == 496) catch @panic("test failure");
13843 expect(v[16] == 497) catch @panic("test failure");
13844 expect(v[17] == 498) catch @panic("test failure");
13845 expect(v[18] == 499) catch @panic("test failure");
13846 expect(v[19] == 500) catch @panic("test failure");
13847 expect(v[20] == 501) catch @panic("test failure");
13848 expect(v[21] == 502) catch @panic("test failure");
13849 expect(v[22] == 503) catch @panic("test failure");
13850 expect(v[23] == 504) catch @panic("test failure");
13851 expect(v[24] == 505) catch @panic("test failure");
13852 expect(v[25] == 506) catch @panic("test failure");
13853 expect(v[26] == 507) catch @panic("test failure");
13854 expect(v[27] == 508) catch @panic("test failure");
13855 expect(v[28] == 509) catch @panic("test failure");
13856 expect(v[29] == 510) catch @panic("test failure");
13857 expect(v[30] == 511) catch @panic("test failure");
13858 expect(v[31] == 512) catch @panic("test failure");
13859 expect(v[32] == 513) catch @panic("test failure");
13860 expect(v[33] == 514) catch @panic("test failure");
13861 expect(v[34] == 515) catch @panic("test failure");
13862 expect(v[35] == 516) catch @panic("test failure");
13863 expect(v[36] == 517) catch @panic("test failure");
13864 expect(v[37] == 518) catch @panic("test failure");
13865 expect(v[38] == 519) catch @panic("test failure");
13866 expect(v[39] == 520) catch @panic("test failure");
13867 expect(v[40] == 521) catch @panic("test failure");
13868 expect(v[41] == 522) catch @panic("test failure");
13869 expect(v[42] == 523) catch @panic("test failure");
13870 expect(v[43] == 524) catch @panic("test failure");
13871 expect(v[44] == 525) catch @panic("test failure");
13872 expect(v[45] == 526) catch @panic("test failure");
13873 expect(v[46] == 527) catch @panic("test failure");
13874 expect(v[47] == 528) catch @panic("test failure");
13875 expect(i == 48) catch @panic("test failure");
13876}
13877
13878extern fn c_ret_vector_48_f32() @Vector(48, f32);
13879extern fn c_vector_48_f32(@Vector(48, f32), usize) void;
13880extern fn c_test_vector_48_f32() void;
13881
13882test "@Vector(48, f32)" {
13883 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
13884 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
13885 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
13886 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
13887
13888 const v = c_ret_vector_48_f32();
13889 try expect(v[0] == 529);
13890 try expect(v[1] == 530);
13891 try expect(v[2] == 531);
13892 try expect(v[3] == 532);
13893 try expect(v[4] == 533);
13894 try expect(v[5] == 534);
13895 try expect(v[6] == 535);
13896 try expect(v[7] == 536);
13897 try expect(v[8] == 537);
13898 try expect(v[9] == 538);
13899 try expect(v[10] == 539);
13900 try expect(v[11] == 540);
13901 try expect(v[12] == 541);
13902 try expect(v[13] == 542);
13903 try expect(v[14] == 543);
13904 try expect(v[15] == 544);
13905 try expect(v[16] == 545);
13906 try expect(v[17] == 546);
13907 try expect(v[18] == 547);
13908 try expect(v[19] == 548);
13909 try expect(v[20] == 549);
13910 try expect(v[21] == 550);
13911 try expect(v[22] == 551);
13912 try expect(v[23] == 552);
13913 try expect(v[24] == 553);
13914 try expect(v[25] == 554);
13915 try expect(v[26] == 555);
13916 try expect(v[27] == 556);
13917 try expect(v[28] == 557);
13918 try expect(v[29] == 558);
13919 try expect(v[30] == 559);
13920 try expect(v[31] == 560);
13921 try expect(v[32] == 561);
13922 try expect(v[33] == 562);
13923 try expect(v[34] == 563);
13924 try expect(v[35] == 564);
13925 try expect(v[36] == 565);
13926 try expect(v[37] == 566);
13927 try expect(v[38] == 567);
13928 try expect(v[39] == 568);
13929 try expect(v[40] == 569);
13930 try expect(v[41] == 570);
13931 try expect(v[42] == 571);
13932 try expect(v[43] == 572);
13933 try expect(v[44] == 573);
13934 try expect(v[45] == 574);
13935 try expect(v[46] == 575);
13936 try expect(v[47] == 576);
13937 c_vector_48_f32(.{
13938 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
13939 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
13940 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
13941 }, 48);
13942 c_test_vector_48_f32();
13943}
13944
13945export fn zig_ret_vector_64_f32() @Vector(64, f32) {
13946 return .{
13947 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
13948 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
13949 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
13950 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
13951 };
13952}
13953export fn zig_vector_64_f32(v: @Vector(64, f32), i: usize) void {
13954 expect(v[0] == 689) catch @panic("test failure");
13955 expect(v[1] == 690) catch @panic("test failure");
13956 expect(v[2] == 691) catch @panic("test failure");
13957 expect(v[3] == 692) catch @panic("test failure");
13958 expect(v[4] == 693) catch @panic("test failure");
13959 expect(v[5] == 694) catch @panic("test failure");
13960 expect(v[6] == 695) catch @panic("test failure");
13961 expect(v[7] == 696) catch @panic("test failure");
13962 expect(v[8] == 697) catch @panic("test failure");
13963 expect(v[9] == 698) catch @panic("test failure");
13964 expect(v[10] == 699) catch @panic("test failure");
13965 expect(v[11] == 700) catch @panic("test failure");
13966 expect(v[12] == 701) catch @panic("test failure");
13967 expect(v[13] == 702) catch @panic("test failure");
13968 expect(v[14] == 703) catch @panic("test failure");
13969 expect(v[15] == 704) catch @panic("test failure");
13970 expect(v[16] == 705) catch @panic("test failure");
13971 expect(v[17] == 706) catch @panic("test failure");
13972 expect(v[18] == 707) catch @panic("test failure");
13973 expect(v[19] == 708) catch @panic("test failure");
13974 expect(v[20] == 709) catch @panic("test failure");
13975 expect(v[21] == 710) catch @panic("test failure");
13976 expect(v[22] == 711) catch @panic("test failure");
13977 expect(v[23] == 712) catch @panic("test failure");
13978 expect(v[24] == 713) catch @panic("test failure");
13979 expect(v[25] == 714) catch @panic("test failure");
13980 expect(v[26] == 715) catch @panic("test failure");
13981 expect(v[27] == 716) catch @panic("test failure");
13982 expect(v[28] == 717) catch @panic("test failure");
13983 expect(v[29] == 718) catch @panic("test failure");
13984 expect(v[30] == 719) catch @panic("test failure");
13985 expect(v[31] == 720) catch @panic("test failure");
13986 expect(v[32] == 721) catch @panic("test failure");
13987 expect(v[33] == 722) catch @panic("test failure");
13988 expect(v[34] == 723) catch @panic("test failure");
13989 expect(v[35] == 724) catch @panic("test failure");
13990 expect(v[36] == 725) catch @panic("test failure");
13991 expect(v[37] == 726) catch @panic("test failure");
13992 expect(v[38] == 727) catch @panic("test failure");
13993 expect(v[39] == 728) catch @panic("test failure");
13994 expect(v[40] == 729) catch @panic("test failure");
13995 expect(v[41] == 730) catch @panic("test failure");
13996 expect(v[42] == 731) catch @panic("test failure");
13997 expect(v[43] == 732) catch @panic("test failure");
13998 expect(v[44] == 733) catch @panic("test failure");
13999 expect(v[45] == 734) catch @panic("test failure");
14000 expect(v[46] == 735) catch @panic("test failure");
14001 expect(v[47] == 736) catch @panic("test failure");
14002 expect(v[48] == 737) catch @panic("test failure");
14003 expect(v[49] == 738) catch @panic("test failure");
14004 expect(v[50] == 739) catch @panic("test failure");
14005 expect(v[51] == 740) catch @panic("test failure");
14006 expect(v[52] == 741) catch @panic("test failure");
14007 expect(v[53] == 742) catch @panic("test failure");
14008 expect(v[54] == 743) catch @panic("test failure");
14009 expect(v[55] == 744) catch @panic("test failure");
14010 expect(v[56] == 745) catch @panic("test failure");
14011 expect(v[57] == 746) catch @panic("test failure");
14012 expect(v[58] == 747) catch @panic("test failure");
14013 expect(v[59] == 748) catch @panic("test failure");
14014 expect(v[60] == 749) catch @panic("test failure");
14015 expect(v[61] == 750) catch @panic("test failure");
14016 expect(v[62] == 751) catch @panic("test failure");
14017 expect(v[63] == 752) catch @panic("test failure");
14018 expect(i == 64) catch @panic("test failure");
14019}
14020
14021extern fn c_ret_vector_64_f32() @Vector(64, f32);
14022extern fn c_vector_64_f32(@Vector(64, f32), usize) void;
14023extern fn c_test_vector_64_f32() void;
14024
14025test "@Vector(64, f32)" {
14026 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14027 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14028 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
14029 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14030
14031 const v = c_ret_vector_64_f32();
14032 try expect(v[0] == 753);
14033 try expect(v[1] == 754);
14034 try expect(v[2] == 755);
14035 try expect(v[3] == 756);
14036 try expect(v[4] == 757);
14037 try expect(v[5] == 758);
14038 try expect(v[6] == 759);
14039 try expect(v[7] == 760);
14040 try expect(v[8] == 761);
14041 try expect(v[9] == 762);
14042 try expect(v[10] == 763);
14043 try expect(v[11] == 764);
14044 try expect(v[12] == 765);
14045 try expect(v[13] == 766);
14046 try expect(v[14] == 767);
14047 try expect(v[15] == 768);
14048 try expect(v[16] == 769);
14049 try expect(v[17] == 770);
14050 try expect(v[18] == 771);
14051 try expect(v[19] == 772);
14052 try expect(v[20] == 773);
14053 try expect(v[21] == 774);
14054 try expect(v[22] == 775);
14055 try expect(v[23] == 776);
14056 try expect(v[24] == 777);
14057 try expect(v[25] == 778);
14058 try expect(v[26] == 779);
14059 try expect(v[27] == 780);
14060 try expect(v[28] == 781);
14061 try expect(v[29] == 782);
14062 try expect(v[30] == 783);
14063 try expect(v[31] == 784);
14064 try expect(v[32] == 785);
14065 try expect(v[33] == 786);
14066 try expect(v[34] == 787);
14067 try expect(v[35] == 788);
14068 try expect(v[36] == 789);
14069 try expect(v[37] == 790);
14070 try expect(v[38] == 791);
14071 try expect(v[39] == 792);
14072 try expect(v[40] == 793);
14073 try expect(v[41] == 794);
14074 try expect(v[42] == 795);
14075 try expect(v[43] == 796);
14076 try expect(v[44] == 797);
14077 try expect(v[45] == 798);
14078 try expect(v[46] == 799);
14079 try expect(v[47] == 800);
14080 try expect(v[48] == 801);
14081 try expect(v[49] == 802);
14082 try expect(v[50] == 803);
14083 try expect(v[51] == 804);
14084 try expect(v[52] == 805);
14085 try expect(v[53] == 806);
14086 try expect(v[54] == 807);
14087 try expect(v[55] == 808);
14088 try expect(v[56] == 809);
14089 try expect(v[57] == 810);
14090 try expect(v[58] == 811);
14091 try expect(v[59] == 812);
14092 try expect(v[60] == 813);
14093 try expect(v[61] == 814);
14094 try expect(v[62] == 815);
14095 try expect(v[63] == 816);
14096 c_vector_64_f32(.{
14097 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
14098 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
14099 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
14100 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
14101 }, 64);
14102 c_test_vector_64_f32();
14103}
14104
14105export fn zig_ret_vector_96_f32() @Vector(96, f32) {
14106 return .{
14107 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
14108 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
14109 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
14110 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
14111 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
14112 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
14113 };
14114}
14115export fn zig_vector_96_f32(v: @Vector(96, f32), i: usize) void {
14116 expect(v[0] == 986) catch @panic("test failure");
14117 expect(v[1] == 987) catch @panic("test failure");
14118 expect(v[2] == 988) catch @panic("test failure");
14119 expect(v[3] == 989) catch @panic("test failure");
14120 expect(v[4] == 990) catch @panic("test failure");
14121 expect(v[5] == 991) catch @panic("test failure");
14122 expect(v[6] == 992) catch @panic("test failure");
14123 expect(v[7] == 993) catch @panic("test failure");
14124 expect(v[8] == 994) catch @panic("test failure");
14125 expect(v[9] == 995) catch @panic("test failure");
14126 expect(v[10] == 996) catch @panic("test failure");
14127 expect(v[11] == 997) catch @panic("test failure");
14128 expect(v[12] == 998) catch @panic("test failure");
14129 expect(v[13] == 999) catch @panic("test failure");
14130 expect(v[14] == 1000) catch @panic("test failure");
14131 expect(v[15] == 1001) catch @panic("test failure");
14132 expect(v[16] == 1002) catch @panic("test failure");
14133 expect(v[17] == 1003) catch @panic("test failure");
14134 expect(v[18] == 1004) catch @panic("test failure");
14135 expect(v[19] == 1005) catch @panic("test failure");
14136 expect(v[20] == 1006) catch @panic("test failure");
14137 expect(v[21] == 1007) catch @panic("test failure");
14138 expect(v[22] == 1008) catch @panic("test failure");
14139 expect(v[23] == 1009) catch @panic("test failure");
14140 expect(v[24] == 1010) catch @panic("test failure");
14141 expect(v[25] == 1011) catch @panic("test failure");
14142 expect(v[26] == 1012) catch @panic("test failure");
14143 expect(v[27] == 1013) catch @panic("test failure");
14144 expect(v[28] == 1014) catch @panic("test failure");
14145 expect(v[29] == 1015) catch @panic("test failure");
14146 expect(v[30] == 1016) catch @panic("test failure");
14147 expect(v[31] == 1017) catch @panic("test failure");
14148 expect(v[32] == 1018) catch @panic("test failure");
14149 expect(v[33] == 1019) catch @panic("test failure");
14150 expect(v[34] == 1020) catch @panic("test failure");
14151 expect(v[35] == 1021) catch @panic("test failure");
14152 expect(v[36] == 1022) catch @panic("test failure");
14153 expect(v[37] == 1023) catch @panic("test failure");
14154 expect(v[38] == 1024) catch @panic("test failure");
14155 expect(v[39] == 1025) catch @panic("test failure");
14156 expect(v[40] == 1026) catch @panic("test failure");
14157 expect(v[41] == 1027) catch @panic("test failure");
14158 expect(v[42] == 1028) catch @panic("test failure");
14159 expect(v[43] == 1029) catch @panic("test failure");
14160 expect(v[44] == 1030) catch @panic("test failure");
14161 expect(v[45] == 1031) catch @panic("test failure");
14162 expect(v[46] == 1032) catch @panic("test failure");
14163 expect(v[47] == 1033) catch @panic("test failure");
14164 expect(v[48] == 1034) catch @panic("test failure");
14165 expect(v[49] == 1035) catch @panic("test failure");
14166 expect(v[50] == 1036) catch @panic("test failure");
14167 expect(v[51] == 1037) catch @panic("test failure");
14168 expect(v[52] == 1038) catch @panic("test failure");
14169 expect(v[53] == 1039) catch @panic("test failure");
14170 expect(v[54] == 1040) catch @panic("test failure");
14171 expect(v[55] == 1041) catch @panic("test failure");
14172 expect(v[56] == 1042) catch @panic("test failure");
14173 expect(v[57] == 1043) catch @panic("test failure");
14174 expect(v[58] == 1044) catch @panic("test failure");
14175 expect(v[59] == 1045) catch @panic("test failure");
14176 expect(v[60] == 1046) catch @panic("test failure");
14177 expect(v[61] == 1047) catch @panic("test failure");
14178 expect(v[62] == 1048) catch @panic("test failure");
14179 expect(v[63] == 1049) catch @panic("test failure");
14180 expect(v[64] == 1050) catch @panic("test failure");
14181 expect(v[65] == 1051) catch @panic("test failure");
14182 expect(v[66] == 1052) catch @panic("test failure");
14183 expect(v[67] == 1053) catch @panic("test failure");
14184 expect(v[68] == 1054) catch @panic("test failure");
14185 expect(v[69] == 1055) catch @panic("test failure");
14186 expect(v[70] == 1056) catch @panic("test failure");
14187 expect(v[71] == 1057) catch @panic("test failure");
14188 expect(v[72] == 1058) catch @panic("test failure");
14189 expect(v[73] == 1059) catch @panic("test failure");
14190 expect(v[74] == 1060) catch @panic("test failure");
14191 expect(v[75] == 1061) catch @panic("test failure");
14192 expect(v[76] == 1062) catch @panic("test failure");
14193 expect(v[77] == 1063) catch @panic("test failure");
14194 expect(v[78] == 1064) catch @panic("test failure");
14195 expect(v[79] == 1065) catch @panic("test failure");
14196 expect(v[80] == 1066) catch @panic("test failure");
14197 expect(v[81] == 1067) catch @panic("test failure");
14198 expect(v[82] == 1068) catch @panic("test failure");
14199 expect(v[83] == 1069) catch @panic("test failure");
14200 expect(v[84] == 1070) catch @panic("test failure");
14201 expect(v[85] == 1071) catch @panic("test failure");
14202 expect(v[86] == 1072) catch @panic("test failure");
14203 expect(v[87] == 1073) catch @panic("test failure");
14204 expect(v[88] == 1074) catch @panic("test failure");
14205 expect(v[89] == 1075) catch @panic("test failure");
14206 expect(v[90] == 1076) catch @panic("test failure");
14207 expect(v[91] == 1077) catch @panic("test failure");
14208 expect(v[92] == 1078) catch @panic("test failure");
14209 expect(v[93] == 1079) catch @panic("test failure");
14210 expect(v[94] == 1080) catch @panic("test failure");
14211 expect(v[95] == 1081) catch @panic("test failure");
14212 expect(i == 96) catch @panic("test failure");
14213}
14214
14215extern fn c_ret_vector_96_f32() @Vector(96, f32);
14216extern fn c_vector_96_f32(@Vector(96, f32), usize) void;
14217extern fn c_test_vector_96_f32() void;
14218
14219test "@Vector(96, f32)" {
14220 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14221 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14222 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
14223 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14224
14225 const v = c_ret_vector_96_f32();
14226 try expect(v[0] == 1082);
14227 try expect(v[1] == 1083);
14228 try expect(v[2] == 1084);
14229 try expect(v[3] == 1085);
14230 try expect(v[4] == 1086);
14231 try expect(v[5] == 1087);
14232 try expect(v[6] == 1088);
14233 try expect(v[7] == 1089);
14234 try expect(v[8] == 1090);
14235 try expect(v[9] == 1091);
14236 try expect(v[10] == 1092);
14237 try expect(v[11] == 1093);
14238 try expect(v[12] == 1094);
14239 try expect(v[13] == 1095);
14240 try expect(v[14] == 1096);
14241 try expect(v[15] == 1097);
14242 try expect(v[16] == 1098);
14243 try expect(v[17] == 1099);
14244 try expect(v[18] == 1100);
14245 try expect(v[19] == 1101);
14246 try expect(v[20] == 1102);
14247 try expect(v[21] == 1103);
14248 try expect(v[22] == 1104);
14249 try expect(v[23] == 1105);
14250 try expect(v[24] == 1106);
14251 try expect(v[25] == 1107);
14252 try expect(v[26] == 1108);
14253 try expect(v[27] == 1109);
14254 try expect(v[28] == 1110);
14255 try expect(v[29] == 1111);
14256 try expect(v[30] == 1112);
14257 try expect(v[31] == 1113);
14258 try expect(v[32] == 1114);
14259 try expect(v[33] == 1115);
14260 try expect(v[34] == 1116);
14261 try expect(v[35] == 1117);
14262 try expect(v[36] == 1118);
14263 try expect(v[37] == 1119);
14264 try expect(v[38] == 1120);
14265 try expect(v[39] == 1121);
14266 try expect(v[40] == 1122);
14267 try expect(v[41] == 1123);
14268 try expect(v[42] == 1124);
14269 try expect(v[43] == 1125);
14270 try expect(v[44] == 1126);
14271 try expect(v[45] == 1127);
14272 try expect(v[46] == 1128);
14273 try expect(v[47] == 1129);
14274 try expect(v[48] == 1130);
14275 try expect(v[49] == 1131);
14276 try expect(v[50] == 1132);
14277 try expect(v[51] == 1133);
14278 try expect(v[52] == 1134);
14279 try expect(v[53] == 1135);
14280 try expect(v[54] == 1136);
14281 try expect(v[55] == 1137);
14282 try expect(v[56] == 1138);
14283 try expect(v[57] == 1139);
14284 try expect(v[58] == 1140);
14285 try expect(v[59] == 1141);
14286 try expect(v[60] == 1142);
14287 try expect(v[61] == 1143);
14288 try expect(v[62] == 1144);
14289 try expect(v[63] == 1145);
14290 try expect(v[64] == 1146);
14291 try expect(v[65] == 1147);
14292 try expect(v[66] == 1148);
14293 try expect(v[67] == 1149);
14294 try expect(v[68] == 1150);
14295 try expect(v[69] == 1151);
14296 try expect(v[70] == 1152);
14297 try expect(v[71] == 1153);
14298 try expect(v[72] == 1154);
14299 try expect(v[73] == 1155);
14300 try expect(v[74] == 1156);
14301 try expect(v[75] == 1157);
14302 try expect(v[76] == 1158);
14303 try expect(v[77] == 1159);
14304 try expect(v[78] == 1160);
14305 try expect(v[79] == 1161);
14306 try expect(v[80] == 1162);
14307 try expect(v[81] == 1163);
14308 try expect(v[82] == 1164);
14309 try expect(v[83] == 1165);
14310 try expect(v[84] == 1166);
14311 try expect(v[85] == 1167);
14312 try expect(v[86] == 1168);
14313 try expect(v[87] == 1169);
14314 try expect(v[88] == 1170);
14315 try expect(v[89] == 1171);
14316 try expect(v[90] == 1172);
14317 try expect(v[91] == 1173);
14318 try expect(v[92] == 1174);
14319 try expect(v[93] == 1175);
14320 try expect(v[94] == 1176);
14321 try expect(v[95] == 1177);
14322 c_vector_96_f32(.{
14323 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
14324 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
14325 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
14326 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
14327 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
14328 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
14329 }, 96);
14330 c_test_vector_96_f32();
14331}
14332
14333export fn zig_ret_vector_128_f32() @Vector(128, f32) {
14334 return .{
14335 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
14336 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
14337 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
14338 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
14339 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
14340 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
14341 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
14342 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
14343 };
14344}
14345export fn zig_vector_128_f32(v: @Vector(128, f32), i: usize) void {
14346 expect(v[0] == 1402) catch @panic("test failure");
14347 expect(v[1] == 1403) catch @panic("test failure");
14348 expect(v[2] == 1404) catch @panic("test failure");
14349 expect(v[3] == 1405) catch @panic("test failure");
14350 expect(v[4] == 1406) catch @panic("test failure");
14351 expect(v[5] == 1407) catch @panic("test failure");
14352 expect(v[6] == 1408) catch @panic("test failure");
14353 expect(v[7] == 1409) catch @panic("test failure");
14354 expect(v[8] == 1410) catch @panic("test failure");
14355 expect(v[9] == 1411) catch @panic("test failure");
14356 expect(v[10] == 1412) catch @panic("test failure");
14357 expect(v[11] == 1413) catch @panic("test failure");
14358 expect(v[12] == 1414) catch @panic("test failure");
14359 expect(v[13] == 1415) catch @panic("test failure");
14360 expect(v[14] == 1416) catch @panic("test failure");
14361 expect(v[15] == 1417) catch @panic("test failure");
14362 expect(v[16] == 1418) catch @panic("test failure");
14363 expect(v[17] == 1419) catch @panic("test failure");
14364 expect(v[18] == 1420) catch @panic("test failure");
14365 expect(v[19] == 1421) catch @panic("test failure");
14366 expect(v[20] == 1422) catch @panic("test failure");
14367 expect(v[21] == 1423) catch @panic("test failure");
14368 expect(v[22] == 1424) catch @panic("test failure");
14369 expect(v[23] == 1425) catch @panic("test failure");
14370 expect(v[24] == 1426) catch @panic("test failure");
14371 expect(v[25] == 1427) catch @panic("test failure");
14372 expect(v[26] == 1428) catch @panic("test failure");
14373 expect(v[27] == 1429) catch @panic("test failure");
14374 expect(v[28] == 1430) catch @panic("test failure");
14375 expect(v[29] == 1431) catch @panic("test failure");
14376 expect(v[30] == 1432) catch @panic("test failure");
14377 expect(v[31] == 1433) catch @panic("test failure");
14378 expect(v[32] == 1434) catch @panic("test failure");
14379 expect(v[33] == 1435) catch @panic("test failure");
14380 expect(v[34] == 1436) catch @panic("test failure");
14381 expect(v[35] == 1437) catch @panic("test failure");
14382 expect(v[36] == 1438) catch @panic("test failure");
14383 expect(v[37] == 1439) catch @panic("test failure");
14384 expect(v[38] == 1440) catch @panic("test failure");
14385 expect(v[39] == 1441) catch @panic("test failure");
14386 expect(v[40] == 1442) catch @panic("test failure");
14387 expect(v[41] == 1443) catch @panic("test failure");
14388 expect(v[42] == 1444) catch @panic("test failure");
14389 expect(v[43] == 1445) catch @panic("test failure");
14390 expect(v[44] == 1446) catch @panic("test failure");
14391 expect(v[45] == 1447) catch @panic("test failure");
14392 expect(v[46] == 1448) catch @panic("test failure");
14393 expect(v[47] == 1449) catch @panic("test failure");
14394 expect(v[48] == 1450) catch @panic("test failure");
14395 expect(v[49] == 1451) catch @panic("test failure");
14396 expect(v[50] == 1452) catch @panic("test failure");
14397 expect(v[51] == 1453) catch @panic("test failure");
14398 expect(v[52] == 1454) catch @panic("test failure");
14399 expect(v[53] == 1455) catch @panic("test failure");
14400 expect(v[54] == 1456) catch @panic("test failure");
14401 expect(v[55] == 1457) catch @panic("test failure");
14402 expect(v[56] == 1458) catch @panic("test failure");
14403 expect(v[57] == 1459) catch @panic("test failure");
14404 expect(v[58] == 1460) catch @panic("test failure");
14405 expect(v[59] == 1461) catch @panic("test failure");
14406 expect(v[60] == 1462) catch @panic("test failure");
14407 expect(v[61] == 1463) catch @panic("test failure");
14408 expect(v[62] == 1464) catch @panic("test failure");
14409 expect(v[63] == 1465) catch @panic("test failure");
14410 expect(v[64] == 1466) catch @panic("test failure");
14411 expect(v[65] == 1467) catch @panic("test failure");
14412 expect(v[66] == 1468) catch @panic("test failure");
14413 expect(v[67] == 1469) catch @panic("test failure");
14414 expect(v[68] == 1470) catch @panic("test failure");
14415 expect(v[69] == 1471) catch @panic("test failure");
14416 expect(v[70] == 1472) catch @panic("test failure");
14417 expect(v[71] == 1473) catch @panic("test failure");
14418 expect(v[72] == 1474) catch @panic("test failure");
14419 expect(v[73] == 1475) catch @panic("test failure");
14420 expect(v[74] == 1476) catch @panic("test failure");
14421 expect(v[75] == 1477) catch @panic("test failure");
14422 expect(v[76] == 1478) catch @panic("test failure");
14423 expect(v[77] == 1479) catch @panic("test failure");
14424 expect(v[78] == 1480) catch @panic("test failure");
14425 expect(v[79] == 1481) catch @panic("test failure");
14426 expect(v[80] == 1482) catch @panic("test failure");
14427 expect(v[81] == 1483) catch @panic("test failure");
14428 expect(v[82] == 1484) catch @panic("test failure");
14429 expect(v[83] == 1485) catch @panic("test failure");
14430 expect(v[84] == 1486) catch @panic("test failure");
14431 expect(v[85] == 1487) catch @panic("test failure");
14432 expect(v[86] == 1488) catch @panic("test failure");
14433 expect(v[87] == 1489) catch @panic("test failure");
14434 expect(v[88] == 1490) catch @panic("test failure");
14435 expect(v[89] == 1491) catch @panic("test failure");
14436 expect(v[90] == 1492) catch @panic("test failure");
14437 expect(v[91] == 1493) catch @panic("test failure");
14438 expect(v[92] == 1494) catch @panic("test failure");
14439 expect(v[93] == 1495) catch @panic("test failure");
14440 expect(v[94] == 1496) catch @panic("test failure");
14441 expect(v[95] == 1497) catch @panic("test failure");
14442 expect(v[96] == 1498) catch @panic("test failure");
14443 expect(v[97] == 1499) catch @panic("test failure");
14444 expect(v[98] == 1500) catch @panic("test failure");
14445 expect(v[99] == 1501) catch @panic("test failure");
14446 expect(v[100] == 1502) catch @panic("test failure");
14447 expect(v[101] == 1503) catch @panic("test failure");
14448 expect(v[102] == 1504) catch @panic("test failure");
14449 expect(v[103] == 1505) catch @panic("test failure");
14450 expect(v[104] == 1506) catch @panic("test failure");
14451 expect(v[105] == 1507) catch @panic("test failure");
14452 expect(v[106] == 1508) catch @panic("test failure");
14453 expect(v[107] == 1509) catch @panic("test failure");
14454 expect(v[108] == 1510) catch @panic("test failure");
14455 expect(v[109] == 1511) catch @panic("test failure");
14456 expect(v[110] == 1512) catch @panic("test failure");
14457 expect(v[111] == 1513) catch @panic("test failure");
14458 expect(v[112] == 1514) catch @panic("test failure");
14459 expect(v[113] == 1515) catch @panic("test failure");
14460 expect(v[114] == 1516) catch @panic("test failure");
14461 expect(v[115] == 1517) catch @panic("test failure");
14462 expect(v[116] == 1518) catch @panic("test failure");
14463 expect(v[117] == 1519) catch @panic("test failure");
14464 expect(v[118] == 1520) catch @panic("test failure");
14465 expect(v[119] == 1521) catch @panic("test failure");
14466 expect(v[120] == 1522) catch @panic("test failure");
14467 expect(v[121] == 1523) catch @panic("test failure");
14468 expect(v[122] == 1524) catch @panic("test failure");
14469 expect(v[123] == 1525) catch @panic("test failure");
14470 expect(v[124] == 1526) catch @panic("test failure");
14471 expect(v[125] == 1527) catch @panic("test failure");
14472 expect(v[126] == 1528) catch @panic("test failure");
14473 expect(v[127] == 1529) catch @panic("test failure");
14474 expect(i == 128) catch @panic("test failure");
14475}
14476
14477extern fn c_ret_vector_128_f32() @Vector(128, f32);
14478extern fn c_vector_128_f32(@Vector(128, f32), usize) void;
14479extern fn c_test_vector_128_f32() void;
14480
14481test "@Vector(128, f32)" {
14482 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14483 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14484 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
14485 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14486
14487 const v = c_ret_vector_128_f32();
14488 try expect(v[0] == 1530);
14489 try expect(v[1] == 1531);
14490 try expect(v[2] == 1532);
14491 try expect(v[3] == 1533);
14492 try expect(v[4] == 1534);
14493 try expect(v[5] == 1535);
14494 try expect(v[6] == 1536);
14495 try expect(v[7] == 1537);
14496 try expect(v[8] == 1538);
14497 try expect(v[9] == 1539);
14498 try expect(v[10] == 1540);
14499 try expect(v[11] == 1541);
14500 try expect(v[12] == 1542);
14501 try expect(v[13] == 1543);
14502 try expect(v[14] == 1544);
14503 try expect(v[15] == 1545);
14504 try expect(v[16] == 1546);
14505 try expect(v[17] == 1547);
14506 try expect(v[18] == 1548);
14507 try expect(v[19] == 1549);
14508 try expect(v[20] == 1550);
14509 try expect(v[21] == 1551);
14510 try expect(v[22] == 1552);
14511 try expect(v[23] == 1553);
14512 try expect(v[24] == 1554);
14513 try expect(v[25] == 1555);
14514 try expect(v[26] == 1556);
14515 try expect(v[27] == 1557);
14516 try expect(v[28] == 1558);
14517 try expect(v[29] == 1559);
14518 try expect(v[30] == 1560);
14519 try expect(v[31] == 1561);
14520 try expect(v[32] == 1562);
14521 try expect(v[33] == 1563);
14522 try expect(v[34] == 1564);
14523 try expect(v[35] == 1565);
14524 try expect(v[36] == 1566);
14525 try expect(v[37] == 1567);
14526 try expect(v[38] == 1568);
14527 try expect(v[39] == 1569);
14528 try expect(v[40] == 1570);
14529 try expect(v[41] == 1571);
14530 try expect(v[42] == 1572);
14531 try expect(v[43] == 1573);
14532 try expect(v[44] == 1574);
14533 try expect(v[45] == 1575);
14534 try expect(v[46] == 1576);
14535 try expect(v[47] == 1577);
14536 try expect(v[48] == 1578);
14537 try expect(v[49] == 1579);
14538 try expect(v[50] == 1580);
14539 try expect(v[51] == 1581);
14540 try expect(v[52] == 1582);
14541 try expect(v[53] == 1583);
14542 try expect(v[54] == 1584);
14543 try expect(v[55] == 1585);
14544 try expect(v[56] == 1586);
14545 try expect(v[57] == 1587);
14546 try expect(v[58] == 1588);
14547 try expect(v[59] == 1589);
14548 try expect(v[60] == 1590);
14549 try expect(v[61] == 1591);
14550 try expect(v[62] == 1592);
14551 try expect(v[63] == 1593);
14552 try expect(v[64] == 1594);
14553 try expect(v[65] == 1595);
14554 try expect(v[66] == 1596);
14555 try expect(v[67] == 1597);
14556 try expect(v[68] == 1598);
14557 try expect(v[69] == 1599);
14558 try expect(v[70] == 1600);
14559 try expect(v[71] == 1601);
14560 try expect(v[72] == 1602);
14561 try expect(v[73] == 1603);
14562 try expect(v[74] == 1604);
14563 try expect(v[75] == 1605);
14564 try expect(v[76] == 1606);
14565 try expect(v[77] == 1607);
14566 try expect(v[78] == 1608);
14567 try expect(v[79] == 1609);
14568 try expect(v[80] == 1610);
14569 try expect(v[81] == 1611);
14570 try expect(v[82] == 1612);
14571 try expect(v[83] == 1613);
14572 try expect(v[84] == 1614);
14573 try expect(v[85] == 1615);
14574 try expect(v[86] == 1616);
14575 try expect(v[87] == 1617);
14576 try expect(v[88] == 1618);
14577 try expect(v[89] == 1619);
14578 try expect(v[90] == 1620);
14579 try expect(v[91] == 1621);
14580 try expect(v[92] == 1622);
14581 try expect(v[93] == 1623);
14582 try expect(v[94] == 1624);
14583 try expect(v[95] == 1625);
14584 try expect(v[96] == 1626);
14585 try expect(v[97] == 1627);
14586 try expect(v[98] == 1628);
14587 try expect(v[99] == 1629);
14588 try expect(v[100] == 1630);
14589 try expect(v[101] == 1631);
14590 try expect(v[102] == 1632);
14591 try expect(v[103] == 1633);
14592 try expect(v[104] == 1634);
14593 try expect(v[105] == 1635);
14594 try expect(v[106] == 1636);
14595 try expect(v[107] == 1637);
14596 try expect(v[108] == 1638);
14597 try expect(v[109] == 1639);
14598 try expect(v[110] == 1640);
14599 try expect(v[111] == 1641);
14600 try expect(v[112] == 1642);
14601 try expect(v[113] == 1643);
14602 try expect(v[114] == 1644);
14603 try expect(v[115] == 1645);
14604 try expect(v[116] == 1646);
14605 try expect(v[117] == 1647);
14606 try expect(v[118] == 1648);
14607 try expect(v[119] == 1649);
14608 try expect(v[120] == 1650);
14609 try expect(v[121] == 1651);
14610 try expect(v[122] == 1652);
14611 try expect(v[123] == 1653);
14612 try expect(v[124] == 1654);
14613 try expect(v[125] == 1655);
14614 try expect(v[126] == 1656);
14615 try expect(v[127] == 1657);
14616 c_vector_128_f32(.{
14617 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
14618 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
14619 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
14620 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
14621 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
14622 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
14623 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
14624 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
14625 }, 128);
14626 c_test_vector_128_f32();
14627}
14628
14629export fn zig_ret_vector_1_f64() @Vector(1, f64) {
14630 return .{1};
14631}
14632export fn zig_vector_1_f64(v: @Vector(1, f64), i: usize) void {
14633 expect(v[0] == 2) catch @panic("test failure");
14634 expect(i == 1) catch @panic("test failure");
14635}
14636
14637extern fn c_ret_vector_1_f64() @Vector(1, f64);
14638extern fn c_vector_1_f64(@Vector(1, f64), usize) void;
14639extern fn c_test_vector_1_f64() void;
14640
14641test "@Vector(1, f64)" {
14642 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14643 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14644
14645 const v = c_ret_vector_1_f64();
14646 try expect(v[0] == 3);
14647 c_vector_1_f64(.{4}, 1);
14648 c_test_vector_1_f64();
14649}
14650
14651export fn zig_ret_vector_2_f64() @Vector(2, f64) {
14652 return .{ 5, 6 };
14653}
14654export fn zig_vector_2_f64(v: @Vector(2, f64), i: usize) void {
14655 expect(v[0] == 7) catch @panic("test failure");
14656 expect(v[1] == 8) catch @panic("test failure");
14657 expect(i == 2) catch @panic("test failure");
14658}
14659
14660extern fn c_ret_vector_2_f64() @Vector(2, f64);
14661extern fn c_vector_2_f64(@Vector(2, f64), usize) void;
14662extern fn c_test_vector_2_f64() void;
14663
14664test "@Vector(2, f64)" {
14665 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14666
14667 const v = c_ret_vector_2_f64();
14668 try expect(v[0] == 9);
14669 try expect(v[1] == 10);
14670 c_vector_2_f64(.{ 11, 12 }, 2);
14671 c_test_vector_2_f64();
14672}
14673
14674export fn zig_ret_vector_3_f64() @Vector(3, f64) {
14675 return .{ 13, 14, 15 };
14676}
14677export fn zig_vector_3_f64(v: @Vector(3, f64), i: usize) void {
14678 expect(v[0] == 16) catch @panic("test failure");
14679 expect(v[1] == 17) catch @panic("test failure");
14680 expect(v[2] == 18) catch @panic("test failure");
14681 expect(i == 3) catch @panic("test failure");
14682}
14683
14684extern fn c_ret_vector_3_f64() @Vector(3, f64);
14685extern fn c_vector_3_f64(@Vector(3, f64), usize) void;
14686extern fn c_test_vector_3_f64() void;
14687
14688test "@Vector(3, f64)" {
14689 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14690 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14691 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
14692 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14693
14694 const v = c_ret_vector_3_f64();
14695 try expect(v[0] == 19);
14696 try expect(v[1] == 20);
14697 try expect(v[2] == 21);
14698 c_vector_3_f64(.{ 22, 23, 24 }, 3);
14699 c_test_vector_3_f64();
14700}
14701
14702export fn zig_ret_vector_4_f64() @Vector(4, f64) {
14703 return .{ 25, 26, 27, 28 };
14704}
14705export fn zig_vector_4_f64(v: @Vector(4, f64), i: usize) void {
14706 expect(v[0] == 29) catch @panic("test failure");
14707 expect(v[1] == 30) catch @panic("test failure");
14708 expect(v[2] == 31) catch @panic("test failure");
14709 expect(v[3] == 32) catch @panic("test failure");
14710 expect(i == 4) catch @panic("test failure");
14711}
14712
14713extern fn c_ret_vector_4_f64() @Vector(4, f64);
14714extern fn c_vector_4_f64(@Vector(4, f64), usize) void;
14715extern fn c_test_vector_4_f64() void;
14716
14717test "@Vector(4, f64)" {
14718 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14719 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
14720 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14721
14722 const v = c_ret_vector_4_f64();
14723 try expect(v[0] == 33);
14724 try expect(v[1] == 34);
14725 try expect(v[2] == 35);
14726 try expect(v[3] == 36);
14727 c_vector_4_f64(.{ 37, 38, 39, 40 }, 4);
14728 c_test_vector_4_f64();
14729}
14730
14731export fn zig_ret_vector_6_f64() @Vector(6, f64) {
14732 return .{ 41, 42, 43, 44, 45, 46 };
14733}
14734export fn zig_vector_6_f64(v: @Vector(6, f64), i: usize) void {
14735 expect(v[0] == 47) catch @panic("test failure");
14736 expect(v[1] == 48) catch @panic("test failure");
14737 expect(v[2] == 49) catch @panic("test failure");
14738 expect(v[3] == 50) catch @panic("test failure");
14739 expect(v[4] == 51) catch @panic("test failure");
14740 expect(v[5] == 52) catch @panic("test failure");
14741 expect(i == 6) catch @panic("test failure");
14742}
14743
14744extern fn c_ret_vector_6_f64() @Vector(6, f64);
14745extern fn c_vector_6_f64(@Vector(6, f64), usize) void;
14746extern fn c_test_vector_6_f64() void;
14747
14748test "@Vector(6, f64)" {
14749 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14750 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14751 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
14752 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14753
14754 const v = c_ret_vector_6_f64();
14755 try expect(v[0] == 53);
14756 try expect(v[1] == 54);
14757 try expect(v[2] == 55);
14758 try expect(v[3] == 56);
14759 try expect(v[4] == 57);
14760 try expect(v[5] == 58);
14761 c_vector_6_f64(.{ 59, 60, 61, 62, 63, 64 }, 6);
14762 c_test_vector_6_f64();
14763}
14764
14765export fn zig_ret_vector_8_f64() @Vector(8, f64) {
14766 return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
14767}
14768export fn zig_vector_8_f64(v: @Vector(8, f64), i: usize) void {
14769 expect(v[0] == 73) catch @panic("test failure");
14770 expect(v[1] == 74) catch @panic("test failure");
14771 expect(v[2] == 75) catch @panic("test failure");
14772 expect(v[3] == 76) catch @panic("test failure");
14773 expect(v[4] == 77) catch @panic("test failure");
14774 expect(v[5] == 78) catch @panic("test failure");
14775 expect(v[6] == 79) catch @panic("test failure");
14776 expect(v[7] == 80) catch @panic("test failure");
14777 expect(i == 8) catch @panic("test failure");
14778}
14779
14780extern fn c_ret_vector_8_f64() @Vector(8, f64);
14781extern fn c_vector_8_f64(@Vector(8, f64), usize) void;
14782extern fn c_test_vector_8_f64() void;
14783
14784test "@Vector(8, f64)" {
14785 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14786 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
14787 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14788
14789 const v = c_ret_vector_8_f64();
14790 try expect(v[0] == 81);
14791 try expect(v[1] == 82);
14792 try expect(v[2] == 83);
14793 try expect(v[3] == 84);
14794 try expect(v[4] == 85);
14795 try expect(v[5] == 86);
14796 try expect(v[6] == 87);
14797 try expect(v[7] == 88);
14798 c_vector_8_f64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
14799 c_test_vector_8_f64();
14800}
14801
14802export fn zig_ret_vector_12_f64() @Vector(12, f64) {
14803 return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
14804}
14805export fn zig_vector_12_f64(v: @Vector(12, f64), i: usize) void {
14806 expect(v[0] == 109) catch @panic("test failure");
14807 expect(v[1] == 110) catch @panic("test failure");
14808 expect(v[2] == 111) catch @panic("test failure");
14809 expect(v[3] == 112) catch @panic("test failure");
14810 expect(v[4] == 113) catch @panic("test failure");
14811 expect(v[5] == 114) catch @panic("test failure");
14812 expect(v[6] == 115) catch @panic("test failure");
14813 expect(v[7] == 116) catch @panic("test failure");
14814 expect(v[8] == 117) catch @panic("test failure");
14815 expect(v[9] == 118) catch @panic("test failure");
14816 expect(v[10] == 119) catch @panic("test failure");
14817 expect(v[11] == 120) catch @panic("test failure");
14818 expect(i == 12) catch @panic("test failure");
14819}
14820
14821extern fn c_ret_vector_12_f64() @Vector(12, f64);
14822extern fn c_vector_12_f64(@Vector(12, f64), usize) void;
14823extern fn c_test_vector_12_f64() void;
14824
14825test "@Vector(12, f64)" {
14826 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14827 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14828 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
14829 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14830
14831 const v = c_ret_vector_12_f64();
14832 try expect(v[0] == 121);
14833 try expect(v[1] == 122);
14834 try expect(v[2] == 123);
14835 try expect(v[3] == 124);
14836 try expect(v[4] == 125);
14837 try expect(v[5] == 126);
14838 try expect(v[6] == 127);
14839 try expect(v[7] == 128);
14840 try expect(v[8] == 129);
14841 try expect(v[9] == 130);
14842 try expect(v[10] == 131);
14843 try expect(v[11] == 132);
14844 c_vector_12_f64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
14845 c_test_vector_12_f64();
14846}
14847
14848export fn zig_ret_vector_16_f64() @Vector(16, f64) {
14849 return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
14850}
14851export fn zig_vector_16_f64(v: @Vector(16, f64), i: usize) void {
14852 expect(v[0] == 161) catch @panic("test failure");
14853 expect(v[1] == 162) catch @panic("test failure");
14854 expect(v[2] == 163) catch @panic("test failure");
14855 expect(v[3] == 164) catch @panic("test failure");
14856 expect(v[4] == 165) catch @panic("test failure");
14857 expect(v[5] == 166) catch @panic("test failure");
14858 expect(v[6] == 167) catch @panic("test failure");
14859 expect(v[7] == 168) catch @panic("test failure");
14860 expect(v[8] == 169) catch @panic("test failure");
14861 expect(v[9] == 170) catch @panic("test failure");
14862 expect(v[10] == 171) catch @panic("test failure");
14863 expect(v[11] == 172) catch @panic("test failure");
14864 expect(v[12] == 173) catch @panic("test failure");
14865 expect(v[13] == 174) catch @panic("test failure");
14866 expect(v[14] == 175) catch @panic("test failure");
14867 expect(v[15] == 176) catch @panic("test failure");
14868 expect(i == 16) catch @panic("test failure");
14869}
14870
14871extern fn c_ret_vector_16_f64() @Vector(16, f64);
14872extern fn c_vector_16_f64(@Vector(16, f64), usize) void;
14873extern fn c_test_vector_16_f64() void;
14874
14875test "@Vector(16, f64)" {
14876 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14877 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14878 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
14879 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14880
14881 const v = c_ret_vector_16_f64();
14882 try expect(v[0] == 177);
14883 try expect(v[1] == 178);
14884 try expect(v[2] == 179);
14885 try expect(v[3] == 180);
14886 try expect(v[4] == 181);
14887 try expect(v[5] == 182);
14888 try expect(v[6] == 183);
14889 try expect(v[7] == 184);
14890 try expect(v[8] == 185);
14891 try expect(v[9] == 186);
14892 try expect(v[10] == 187);
14893 try expect(v[11] == 188);
14894 try expect(v[12] == 189);
14895 try expect(v[13] == 190);
14896 try expect(v[14] == 191);
14897 try expect(v[15] == 192);
14898 c_vector_16_f64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
14899 c_test_vector_16_f64();
14900}
14901
14902export fn zig_ret_vector_24_f64() @Vector(24, f64) {
14903 return .{
14904 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
14905 225, 226, 227, 228, 229, 230, 231, 232,
14906 };
14907}
14908export fn zig_vector_24_f64(v: @Vector(24, f64), i: usize) void {
14909 expect(v[0] == 233) catch @panic("test failure");
14910 expect(v[1] == 234) catch @panic("test failure");
14911 expect(v[2] == 235) catch @panic("test failure");
14912 expect(v[3] == 236) catch @panic("test failure");
14913 expect(v[4] == 237) catch @panic("test failure");
14914 expect(v[5] == 238) catch @panic("test failure");
14915 expect(v[6] == 239) catch @panic("test failure");
14916 expect(v[7] == 240) catch @panic("test failure");
14917 expect(v[8] == 241) catch @panic("test failure");
14918 expect(v[9] == 242) catch @panic("test failure");
14919 expect(v[10] == 243) catch @panic("test failure");
14920 expect(v[11] == 244) catch @panic("test failure");
14921 expect(v[12] == 245) catch @panic("test failure");
14922 expect(v[13] == 246) catch @panic("test failure");
14923 expect(v[14] == 247) catch @panic("test failure");
14924 expect(v[15] == 248) catch @panic("test failure");
14925 expect(v[16] == 249) catch @panic("test failure");
14926 expect(v[17] == 250) catch @panic("test failure");
14927 expect(v[18] == 251) catch @panic("test failure");
14928 expect(v[19] == 252) catch @panic("test failure");
14929 expect(v[20] == 253) catch @panic("test failure");
14930 expect(v[21] == 254) catch @panic("test failure");
14931 expect(v[22] == 255) catch @panic("test failure");
14932 expect(v[23] == 256) catch @panic("test failure");
14933 expect(i == 24) catch @panic("test failure");
14934}
14935
14936extern fn c_ret_vector_24_f64() @Vector(24, f64);
14937extern fn c_vector_24_f64(@Vector(24, f64), usize) void;
14938extern fn c_test_vector_24_f64() void;
14939
14940test "@Vector(24, f64)" {
14941 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
14942 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
14943 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
14944 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
14945
14946 const v = c_ret_vector_24_f64();
14947 try expect(v[0] == 257);
14948 try expect(v[1] == 258);
14949 try expect(v[2] == 259);
14950 try expect(v[3] == 260);
14951 try expect(v[4] == 261);
14952 try expect(v[5] == 262);
14953 try expect(v[6] == 263);
14954 try expect(v[7] == 264);
14955 try expect(v[8] == 265);
14956 try expect(v[9] == 266);
14957 try expect(v[10] == 267);
14958 try expect(v[11] == 268);
14959 try expect(v[12] == 269);
14960 try expect(v[13] == 270);
14961 try expect(v[14] == 271);
14962 try expect(v[15] == 272);
14963 try expect(v[16] == 273);
14964 try expect(v[17] == 274);
14965 try expect(v[18] == 275);
14966 try expect(v[19] == 276);
14967 try expect(v[20] == 277);
14968 try expect(v[21] == 278);
14969 try expect(v[22] == 279);
14970 try expect(v[23] == 280);
14971 c_vector_24_f64(.{
14972 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
14973 297, 298, 299, 300, 301, 302, 303, 304,
14974 }, 24);
14975 c_test_vector_24_f64();
14976}
14977
14978export fn zig_ret_vector_32_f64() @Vector(32, f64) {
14979 return .{
14980 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
14981 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
14982 };
14983}
14984export fn zig_vector_32_f64(v: @Vector(32, f64), i: usize) void {
14985 expect(v[0] == 337) catch @panic("test failure");
14986 expect(v[1] == 338) catch @panic("test failure");
14987 expect(v[2] == 339) catch @panic("test failure");
14988 expect(v[3] == 340) catch @panic("test failure");
14989 expect(v[4] == 341) catch @panic("test failure");
14990 expect(v[5] == 342) catch @panic("test failure");
14991 expect(v[6] == 343) catch @panic("test failure");
14992 expect(v[7] == 344) catch @panic("test failure");
14993 expect(v[8] == 345) catch @panic("test failure");
14994 expect(v[9] == 346) catch @panic("test failure");
14995 expect(v[10] == 347) catch @panic("test failure");
14996 expect(v[11] == 348) catch @panic("test failure");
14997 expect(v[12] == 349) catch @panic("test failure");
14998 expect(v[13] == 350) catch @panic("test failure");
14999 expect(v[14] == 351) catch @panic("test failure");
15000 expect(v[15] == 352) catch @panic("test failure");
15001 expect(v[16] == 353) catch @panic("test failure");
15002 expect(v[17] == 354) catch @panic("test failure");
15003 expect(v[18] == 355) catch @panic("test failure");
15004 expect(v[19] == 356) catch @panic("test failure");
15005 expect(v[20] == 357) catch @panic("test failure");
15006 expect(v[21] == 358) catch @panic("test failure");
15007 expect(v[22] == 359) catch @panic("test failure");
15008 expect(v[23] == 360) catch @panic("test failure");
15009 expect(v[24] == 361) catch @panic("test failure");
15010 expect(v[25] == 362) catch @panic("test failure");
15011 expect(v[26] == 363) catch @panic("test failure");
15012 expect(v[27] == 364) catch @panic("test failure");
15013 expect(v[28] == 365) catch @panic("test failure");
15014 expect(v[29] == 366) catch @panic("test failure");
15015 expect(v[30] == 367) catch @panic("test failure");
15016 expect(v[31] == 368) catch @panic("test failure");
15017 expect(i == 32) catch @panic("test failure");
15018}
15019
15020extern fn c_ret_vector_32_f64() @Vector(32, f64);
15021extern fn c_vector_32_f64(@Vector(32, f64), usize) void;
15022extern fn c_test_vector_32_f64() void;
15023
15024test "@Vector(32, f64)" {
15025 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
15026 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15027 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
15028 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
15029
15030 const v = c_ret_vector_32_f64();
15031 try expect(v[0] == 369);
15032 try expect(v[1] == 370);
15033 try expect(v[2] == 371);
15034 try expect(v[3] == 372);
15035 try expect(v[4] == 373);
15036 try expect(v[5] == 374);
15037 try expect(v[6] == 375);
15038 try expect(v[7] == 376);
15039 try expect(v[8] == 377);
15040 try expect(v[9] == 378);
15041 try expect(v[10] == 379);
15042 try expect(v[11] == 380);
15043 try expect(v[12] == 381);
15044 try expect(v[13] == 382);
15045 try expect(v[14] == 383);
15046 try expect(v[15] == 384);
15047 try expect(v[16] == 385);
15048 try expect(v[17] == 386);
15049 try expect(v[18] == 387);
15050 try expect(v[19] == 388);
15051 try expect(v[20] == 389);
15052 try expect(v[21] == 390);
15053 try expect(v[22] == 391);
15054 try expect(v[23] == 392);
15055 try expect(v[24] == 393);
15056 try expect(v[25] == 394);
15057 try expect(v[26] == 395);
15058 try expect(v[27] == 396);
15059 try expect(v[28] == 397);
15060 try expect(v[29] == 398);
15061 try expect(v[30] == 399);
15062 try expect(v[31] == 400);
15063 c_vector_32_f64(.{
15064 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
15065 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
15066 }, 32);
15067 c_test_vector_32_f64();
15068}
15069
15070export fn zig_ret_vector_48_f64() @Vector(48, f64) {
15071 return .{
15072 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
15073 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
15074 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
15075 };
15076}
15077export fn zig_vector_48_f64(v: @Vector(48, f64), i: usize) void {
15078 expect(v[0] == 481) catch @panic("test failure");
15079 expect(v[1] == 482) catch @panic("test failure");
15080 expect(v[2] == 483) catch @panic("test failure");
15081 expect(v[3] == 484) catch @panic("test failure");
15082 expect(v[4] == 485) catch @panic("test failure");
15083 expect(v[5] == 486) catch @panic("test failure");
15084 expect(v[6] == 487) catch @panic("test failure");
15085 expect(v[7] == 488) catch @panic("test failure");
15086 expect(v[8] == 489) catch @panic("test failure");
15087 expect(v[9] == 490) catch @panic("test failure");
15088 expect(v[10] == 491) catch @panic("test failure");
15089 expect(v[11] == 492) catch @panic("test failure");
15090 expect(v[12] == 493) catch @panic("test failure");
15091 expect(v[13] == 494) catch @panic("test failure");
15092 expect(v[14] == 495) catch @panic("test failure");
15093 expect(v[15] == 496) catch @panic("test failure");
15094 expect(v[16] == 497) catch @panic("test failure");
15095 expect(v[17] == 498) catch @panic("test failure");
15096 expect(v[18] == 499) catch @panic("test failure");
15097 expect(v[19] == 500) catch @panic("test failure");
15098 expect(v[20] == 501) catch @panic("test failure");
15099 expect(v[21] == 502) catch @panic("test failure");
15100 expect(v[22] == 503) catch @panic("test failure");
15101 expect(v[23] == 504) catch @panic("test failure");
15102 expect(v[24] == 505) catch @panic("test failure");
15103 expect(v[25] == 506) catch @panic("test failure");
15104 expect(v[26] == 507) catch @panic("test failure");
15105 expect(v[27] == 508) catch @panic("test failure");
15106 expect(v[28] == 509) catch @panic("test failure");
15107 expect(v[29] == 510) catch @panic("test failure");
15108 expect(v[30] == 511) catch @panic("test failure");
15109 expect(v[31] == 512) catch @panic("test failure");
15110 expect(v[32] == 513) catch @panic("test failure");
15111 expect(v[33] == 514) catch @panic("test failure");
15112 expect(v[34] == 515) catch @panic("test failure");
15113 expect(v[35] == 516) catch @panic("test failure");
15114 expect(v[36] == 517) catch @panic("test failure");
15115 expect(v[37] == 518) catch @panic("test failure");
15116 expect(v[38] == 519) catch @panic("test failure");
15117 expect(v[39] == 520) catch @panic("test failure");
15118 expect(v[40] == 521) catch @panic("test failure");
15119 expect(v[41] == 522) catch @panic("test failure");
15120 expect(v[42] == 523) catch @panic("test failure");
15121 expect(v[43] == 524) catch @panic("test failure");
15122 expect(v[44] == 525) catch @panic("test failure");
15123 expect(v[45] == 526) catch @panic("test failure");
15124 expect(v[46] == 527) catch @panic("test failure");
15125 expect(v[47] == 528) catch @panic("test failure");
15126 expect(i == 48) catch @panic("test failure");
15127}
15128
15129extern fn c_ret_vector_48_f64() @Vector(48, f64);
15130extern fn c_vector_48_f64(@Vector(48, f64), usize) void;
15131extern fn c_test_vector_48_f64() void;
15132
15133test "@Vector(48, f64)" {
15134 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
15135 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15136 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
15137 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
15138
15139 const v = c_ret_vector_48_f64();
15140 try expect(v[0] == 529);
15141 try expect(v[1] == 530);
15142 try expect(v[2] == 531);
15143 try expect(v[3] == 532);
15144 try expect(v[4] == 533);
15145 try expect(v[5] == 534);
15146 try expect(v[6] == 535);
15147 try expect(v[7] == 536);
15148 try expect(v[8] == 537);
15149 try expect(v[9] == 538);
15150 try expect(v[10] == 539);
15151 try expect(v[11] == 540);
15152 try expect(v[12] == 541);
15153 try expect(v[13] == 542);
15154 try expect(v[14] == 543);
15155 try expect(v[15] == 544);
15156 try expect(v[16] == 545);
15157 try expect(v[17] == 546);
15158 try expect(v[18] == 547);
15159 try expect(v[19] == 548);
15160 try expect(v[20] == 549);
15161 try expect(v[21] == 550);
15162 try expect(v[22] == 551);
15163 try expect(v[23] == 552);
15164 try expect(v[24] == 553);
15165 try expect(v[25] == 554);
15166 try expect(v[26] == 555);
15167 try expect(v[27] == 556);
15168 try expect(v[28] == 557);
15169 try expect(v[29] == 558);
15170 try expect(v[30] == 559);
15171 try expect(v[31] == 560);
15172 try expect(v[32] == 561);
15173 try expect(v[33] == 562);
15174 try expect(v[34] == 563);
15175 try expect(v[35] == 564);
15176 try expect(v[36] == 565);
15177 try expect(v[37] == 566);
15178 try expect(v[38] == 567);
15179 try expect(v[39] == 568);
15180 try expect(v[40] == 569);
15181 try expect(v[41] == 570);
15182 try expect(v[42] == 571);
15183 try expect(v[43] == 572);
15184 try expect(v[44] == 573);
15185 try expect(v[45] == 574);
15186 try expect(v[46] == 575);
15187 try expect(v[47] == 576);
15188 c_vector_48_f64(.{
15189 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
15190 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
15191 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
15192 }, 48);
15193 c_test_vector_48_f64();
15194}
15195
15196export fn zig_ret_vector_64_f64() @Vector(64, f64) {
15197 return .{
15198 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
15199 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
15200 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
15201 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
15202 };
15203}
15204export fn zig_vector_64_f64(v: @Vector(64, f64), i: usize) void {
15205 expect(v[0] == 689) catch @panic("test failure");
15206 expect(v[1] == 690) catch @panic("test failure");
15207 expect(v[2] == 691) catch @panic("test failure");
15208 expect(v[3] == 692) catch @panic("test failure");
15209 expect(v[4] == 693) catch @panic("test failure");
15210 expect(v[5] == 694) catch @panic("test failure");
15211 expect(v[6] == 695) catch @panic("test failure");
15212 expect(v[7] == 696) catch @panic("test failure");
15213 expect(v[8] == 697) catch @panic("test failure");
15214 expect(v[9] == 698) catch @panic("test failure");
15215 expect(v[10] == 699) catch @panic("test failure");
15216 expect(v[11] == 700) catch @panic("test failure");
15217 expect(v[12] == 701) catch @panic("test failure");
15218 expect(v[13] == 702) catch @panic("test failure");
15219 expect(v[14] == 703) catch @panic("test failure");
15220 expect(v[15] == 704) catch @panic("test failure");
15221 expect(v[16] == 705) catch @panic("test failure");
15222 expect(v[17] == 706) catch @panic("test failure");
15223 expect(v[18] == 707) catch @panic("test failure");
15224 expect(v[19] == 708) catch @panic("test failure");
15225 expect(v[20] == 709) catch @panic("test failure");
15226 expect(v[21] == 710) catch @panic("test failure");
15227 expect(v[22] == 711) catch @panic("test failure");
15228 expect(v[23] == 712) catch @panic("test failure");
15229 expect(v[24] == 713) catch @panic("test failure");
15230 expect(v[25] == 714) catch @panic("test failure");
15231 expect(v[26] == 715) catch @panic("test failure");
15232 expect(v[27] == 716) catch @panic("test failure");
15233 expect(v[28] == 717) catch @panic("test failure");
15234 expect(v[29] == 718) catch @panic("test failure");
15235 expect(v[30] == 719) catch @panic("test failure");
15236 expect(v[31] == 720) catch @panic("test failure");
15237 expect(v[32] == 721) catch @panic("test failure");
15238 expect(v[33] == 722) catch @panic("test failure");
15239 expect(v[34] == 723) catch @panic("test failure");
15240 expect(v[35] == 724) catch @panic("test failure");
15241 expect(v[36] == 725) catch @panic("test failure");
15242 expect(v[37] == 726) catch @panic("test failure");
15243 expect(v[38] == 727) catch @panic("test failure");
15244 expect(v[39] == 728) catch @panic("test failure");
15245 expect(v[40] == 729) catch @panic("test failure");
15246 expect(v[41] == 730) catch @panic("test failure");
15247 expect(v[42] == 731) catch @panic("test failure");
15248 expect(v[43] == 732) catch @panic("test failure");
15249 expect(v[44] == 733) catch @panic("test failure");
15250 expect(v[45] == 734) catch @panic("test failure");
15251 expect(v[46] == 735) catch @panic("test failure");
15252 expect(v[47] == 736) catch @panic("test failure");
15253 expect(v[48] == 737) catch @panic("test failure");
15254 expect(v[49] == 738) catch @panic("test failure");
15255 expect(v[50] == 739) catch @panic("test failure");
15256 expect(v[51] == 740) catch @panic("test failure");
15257 expect(v[52] == 741) catch @panic("test failure");
15258 expect(v[53] == 742) catch @panic("test failure");
15259 expect(v[54] == 743) catch @panic("test failure");
15260 expect(v[55] == 744) catch @panic("test failure");
15261 expect(v[56] == 745) catch @panic("test failure");
15262 expect(v[57] == 746) catch @panic("test failure");
15263 expect(v[58] == 747) catch @panic("test failure");
15264 expect(v[59] == 748) catch @panic("test failure");
15265 expect(v[60] == 749) catch @panic("test failure");
15266 expect(v[61] == 750) catch @panic("test failure");
15267 expect(v[62] == 751) catch @panic("test failure");
15268 expect(v[63] == 752) catch @panic("test failure");
15269 expect(i == 64) catch @panic("test failure");
15270}
15271
15272extern fn c_ret_vector_64_f64() @Vector(64, f64);
15273extern fn c_vector_64_f64(@Vector(64, f64), usize) void;
15274extern fn c_test_vector_64_f64() void;
15275
15276test "@Vector(64, f64)" {
15277 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
15278 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15279 if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
15280 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
15281
15282 const v = c_ret_vector_64_f64();
15283 try expect(v[0] == 753);
15284 try expect(v[1] == 754);
15285 try expect(v[2] == 755);
15286 try expect(v[3] == 756);
15287 try expect(v[4] == 757);
15288 try expect(v[5] == 758);
15289 try expect(v[6] == 759);
15290 try expect(v[7] == 760);
15291 try expect(v[8] == 761);
15292 try expect(v[9] == 762);
15293 try expect(v[10] == 763);
15294 try expect(v[11] == 764);
15295 try expect(v[12] == 765);
15296 try expect(v[13] == 766);
15297 try expect(v[14] == 767);
15298 try expect(v[15] == 768);
15299 try expect(v[16] == 769);
15300 try expect(v[17] == 770);
15301 try expect(v[18] == 771);
15302 try expect(v[19] == 772);
15303 try expect(v[20] == 773);
15304 try expect(v[21] == 774);
15305 try expect(v[22] == 775);
15306 try expect(v[23] == 776);
15307 try expect(v[24] == 777);
15308 try expect(v[25] == 778);
15309 try expect(v[26] == 779);
15310 try expect(v[27] == 780);
15311 try expect(v[28] == 781);
15312 try expect(v[29] == 782);
15313 try expect(v[30] == 783);
15314 try expect(v[31] == 784);
15315 try expect(v[32] == 785);
15316 try expect(v[33] == 786);
15317 try expect(v[34] == 787);
15318 try expect(v[35] == 788);
15319 try expect(v[36] == 789);
15320 try expect(v[37] == 790);
15321 try expect(v[38] == 791);
15322 try expect(v[39] == 792);
15323 try expect(v[40] == 793);
15324 try expect(v[41] == 794);
15325 try expect(v[42] == 795);
15326 try expect(v[43] == 796);
15327 try expect(v[44] == 797);
15328 try expect(v[45] == 798);
15329 try expect(v[46] == 799);
15330 try expect(v[47] == 800);
15331 try expect(v[48] == 801);
15332 try expect(v[49] == 802);
15333 try expect(v[50] == 803);
15334 try expect(v[51] == 804);
15335 try expect(v[52] == 805);
15336 try expect(v[53] == 806);
15337 try expect(v[54] == 807);
15338 try expect(v[55] == 808);
15339 try expect(v[56] == 809);
15340 try expect(v[57] == 810);
15341 try expect(v[58] == 811);
15342 try expect(v[59] == 812);
15343 try expect(v[60] == 813);
15344 try expect(v[61] == 814);
15345 try expect(v[62] == 815);
15346 try expect(v[63] == 816);
15347 c_vector_64_f64(.{
15348 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
15349 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
15350 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
15351 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
15352 }, 64);
15353 c_test_vector_64_f64();
15354}
15355
15356const Struct_u8 = extern struct {
15357 a: u8,
15358};
15359
15360export fn zig_ret_struct_u8() Struct_u8 {
15361 return .{ .a = 1 };
15362}
15363export fn zig_struct_u8(s: Struct_u8, i: usize) void {
15364 expect(s.a == 2) catch @panic("test failure");
15365 expect(i == 3) catch @panic("test failure");
15366}
15367
15368extern fn c_ret_struct_u8() Struct_u8;
15369extern fn c_struct_u8(Struct_u8, usize) void;
15370extern fn c_test_struct_u8() void;
15371
15372test "struct u8" {
15373 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15374 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15375 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15376
15377 const s = c_ret_struct_u8();
15378 try expect(s.a == 4);
15379 c_struct_u8(.{ .a = 5 }, 6);
15380 c_test_struct_u8();
15381}
15382
15383const Struct_u8_u8 = extern struct {
15384 a: u8,
15385 b: u8,
15386};
15387
15388export fn zig_ret_struct_u8_u8() Struct_u8_u8 {
15389 return .{ .a = 1, .b = 2 };
15390}
15391export fn zig_struct_u8_u8(s: Struct_u8_u8, i: usize) void {
15392 expect(s.a == 3) catch @panic("test failure");
15393 expect(s.b == 4) catch @panic("test failure");
15394 expect(i == 5) catch @panic("test failure");
15395}
15396
15397extern fn c_ret_struct_u8_u8() Struct_u8_u8;
15398extern fn c_struct_u8_u8(Struct_u8_u8, usize) void;
15399extern fn c_test_struct_u8_u8() void;
15400
15401test "struct u8, u8" {
15402 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15403 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15404 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15405 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15406 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15407
15408 const s = c_ret_struct_u8_u8();
15409 try expect(s.a == 6);
15410 try expect(s.b == 7);
15411 c_struct_u8_u8(.{ .a = 8, .b = 9 }, 10);
15412 c_test_struct_u8_u8();
15413}
15414
15415const Struct_u8_u8_u8 = extern struct {
15416 a: u8,
15417 b: u8,
15418 c: u8,
15419};
15420
15421export fn zig_ret_struct_u8_u8_u8() Struct_u8_u8_u8 {
15422 return .{ .a = 1, .b = 2, .c = 3 };
15423}
15424export fn zig_struct_u8_u8_u8(s: Struct_u8_u8_u8, i: usize) void {
15425 expect(s.a == 4) catch @panic("test failure");
15426 expect(s.b == 5) catch @panic("test failure");
15427 expect(s.c == 6) catch @panic("test failure");
15428 expect(i == 7) catch @panic("test failure");
15429}
15430
15431extern fn c_ret_struct_u8_u8_u8() Struct_u8_u8_u8;
15432extern fn c_struct_u8_u8_u8(Struct_u8_u8_u8, usize) void;
15433extern fn c_test_struct_u8_u8_u8() void;
15434
15435test "struct u8, u8, u8" {
15436 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15437 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15438 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15439 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15440 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15441
15442 const s = c_ret_struct_u8_u8_u8();
15443 try expect(s.a == 8);
15444 try expect(s.b == 9);
15445 try expect(s.c == 10);
15446 c_struct_u8_u8_u8(.{ .a = 11, .b = 12, .c = 13 }, 14);
15447 c_test_struct_u8_u8_u8();
15448}
15449
15450const Struct_u8_u8_u8_u8 = extern struct {
15451 a: u8,
15452 b: u8,
15453 c: u8,
15454 d: u8,
15455};
15456
15457export fn zig_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8 {
15458 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
15459}
15460export fn zig_struct_u8_u8_u8_u8(s: Struct_u8_u8_u8_u8, i: usize) void {
15461 expect(s.a == 5) catch @panic("test failure");
15462 expect(s.b == 6) catch @panic("test failure");
15463 expect(s.c == 7) catch @panic("test failure");
15464 expect(s.d == 8) catch @panic("test failure");
15465 expect(i == 9) catch @panic("test failure");
15466}
15467
15468extern fn c_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8;
15469extern fn c_struct_u8_u8_u8_u8(Struct_u8_u8_u8_u8, usize) void;
15470extern fn c_test_struct_u8_u8_u8_u8() void;
15471
15472test "struct u8, u8, u8, u8" {
15473 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15474 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15475 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15476 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15477 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15478
15479 const s = c_ret_struct_u8_u8_u8_u8();
15480 try expect(s.a == 10);
15481 try expect(s.b == 11);
15482 try expect(s.c == 12);
15483 try expect(s.d == 13);
15484 c_struct_u8_u8_u8_u8(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
15485 c_test_struct_u8_u8_u8_u8();
15486}
15487
15488const Struct_u16 = extern struct {
15489 a: u16,
15490};
15491
15492export fn zig_ret_struct_u16() Struct_u16 {
15493 return .{ .a = 1 };
15494}
15495export fn zig_struct_u16(s: Struct_u16, i: usize) void {
15496 expect(s.a == 2) catch @panic("test failure");
15497 expect(i == 3) catch @panic("test failure");
15498}
15499
15500extern fn c_ret_struct_u16() Struct_u16;
15501extern fn c_struct_u16(Struct_u16, usize) void;
15502extern fn c_test_struct_u16() void;
15503
15504test "struct u16" {
15505 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15506 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15507 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15508
15509 const s = c_ret_struct_u16();
15510 try expect(s.a == 4);
15511 c_struct_u16(.{ .a = 5 }, 6);
15512 c_test_struct_u16();
15513}
15514
15515const Struct_u16_u16 = extern struct {
15516 a: u16,
15517 b: u16,
15518};
15519
15520export fn zig_ret_struct_u16_u16() Struct_u16_u16 {
15521 return .{ .a = 1, .b = 2 };
15522}
15523export fn zig_struct_u16_u16(s: Struct_u16_u16, i: usize) void {
15524 expect(s.a == 3) catch @panic("test failure");
15525 expect(s.b == 4) catch @panic("test failure");
15526 expect(i == 5) catch @panic("test failure");
15527}
15528
15529extern fn c_ret_struct_u16_u16() Struct_u16_u16;
15530extern fn c_struct_u16_u16(Struct_u16_u16, usize) void;
15531extern fn c_test_struct_u16_u16() void;
15532
15533test "struct u16, u16" {
15534 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15535 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15536 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15537 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15538 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15539
15540 const s = c_ret_struct_u16_u16();
15541 try expect(s.a == 6);
15542 try expect(s.b == 7);
15543 c_struct_u16_u16(.{ .a = 8, .b = 9 }, 10);
15544 c_test_struct_u16_u16();
15545}
15546
15547const Struct_u16_u16_u16 = extern struct {
15548 a: u16,
15549 b: u16,
15550 c: u16,
15551};
15552
15553export fn zig_ret_struct_u16_u16_u16() Struct_u16_u16_u16 {
15554 return .{ .a = 1, .b = 2, .c = 3 };
15555}
15556export fn zig_struct_u16_u16_u16(s: Struct_u16_u16_u16, i: usize) void {
15557 expect(s.a == 4) catch @panic("test failure");
15558 expect(s.b == 5) catch @panic("test failure");
15559 expect(s.c == 6) catch @panic("test failure");
15560 expect(i == 7) catch @panic("test failure");
15561}
15562
15563extern fn c_ret_struct_u16_u16_u16() Struct_u16_u16_u16;
15564extern fn c_struct_u16_u16_u16(Struct_u16_u16_u16, usize) void;
15565extern fn c_test_struct_u16_u16_u16() void;
15566
15567test "struct u16, u16, u16" {
15568 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15569 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15570 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15571 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15572 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
15573 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15574
15575 const s = c_ret_struct_u16_u16_u16();
15576 try expect(s.a == 8);
15577 try expect(s.b == 9);
15578 try expect(s.c == 10);
15579 c_struct_u16_u16_u16(.{ .a = 11, .b = 12, .c = 13 }, 14);
15580 c_test_struct_u16_u16_u16();
15581}
15582
15583const Struct_u16_u16_u16_u16 = extern struct {
15584 a: u16,
15585 b: u16,
15586 c: u16,
15587 d: u16,
15588};
15589
15590export fn zig_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16 {
15591 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
15592}
15593export fn zig_struct_u16_u16_u16_u16(s: Struct_u16_u16_u16_u16, i: usize) void {
15594 expect(s.a == 5) catch @panic("test failure");
15595 expect(s.b == 6) catch @panic("test failure");
15596 expect(s.c == 7) catch @panic("test failure");
15597 expect(s.d == 8) catch @panic("test failure");
15598 expect(i == 9) catch @panic("test failure");
15599}
15600
15601extern fn c_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16;
15602extern fn c_struct_u16_u16_u16_u16(Struct_u16_u16_u16_u16, usize) void;
15603extern fn c_test_struct_u16_u16_u16_u16() void;
15604
15605test "struct u16, u16, u16, u16" {
15606 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15607 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15608 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15609 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15610 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
15611 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
15612
15613 const s = c_ret_struct_u16_u16_u16_u16();
15614 try expect(s.a == 10);
15615 try expect(s.b == 11);
15616 try expect(s.c == 12);
15617 try expect(s.d == 13);
15618 c_struct_u16_u16_u16_u16(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
15619 c_test_struct_u16_u16_u16_u16();
15620}
15621
15622const Struct_u32 = extern struct {
15623 a: u32,
15624};
15625
15626export fn zig_ret_struct_u32() Struct_u32 {
15627 return .{ .a = 1 };
15628}
15629export fn zig_struct_u32(s: Struct_u32, i: usize) void {
15630 expect(s.a == 2) catch @panic("test failure");
15631 expect(i == 3) catch @panic("test failure");
15632}
15633
15634extern fn c_ret_struct_u32() Struct_u32;
15635extern fn c_struct_u32(Struct_u32, usize) void;
15636extern fn c_test_struct_u32() void;
15637
15638test "struct u32" {
15639 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15640 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15641 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15642
15643 const s = c_ret_struct_u32();
15644 try expect(s.a == 4);
15645 c_struct_u32(.{ .a = 5 }, 6);
15646 c_test_struct_u32();
15647}
15648
15649const Struct_u32_u32 = extern struct {
15650 a: u32,
15651 b: u32,
15652};
15653
15654export fn zig_ret_struct_u32_u32() Struct_u32_u32 {
15655 return .{ .a = 1, .b = 2 };
15656}
15657export fn zig_struct_u32_u32(s: Struct_u32_u32, i: usize) void {
15658 expect(s.a == 3) catch @panic("test failure");
15659 expect(s.b == 4) catch @panic("test failure");
15660 expect(i == 5) catch @panic("test failure");
15661}
15662
15663extern fn c_ret_struct_u32_u32() Struct_u32_u32;
15664extern fn c_struct_u32_u32(Struct_u32_u32, usize) void;
15665extern fn c_test_struct_u32_u32() void;
15666
15667test "struct u32, u32" {
15668 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15669 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15670 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15671 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
15672 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15673
15674 const s = c_ret_struct_u32_u32();
15675 try expect(s.a == 6);
15676 try expect(s.b == 7);
15677 c_struct_u32_u32(.{ .a = 8, .b = 9 }, 10);
15678 c_test_struct_u32_u32();
15679}
15680
15681const Struct_u32_u32_u32 = extern struct {
15682 a: u32,
15683 b: u32,
15684 c: u32,
15685};
15686
15687export fn zig_ret_struct_u32_u32_u32() Struct_u32_u32_u32 {
15688 return .{ .a = 1, .b = 2, .c = 3 };
15689}
15690export fn zig_struct_u32_u32_u32(s: Struct_u32_u32_u32, i: usize) void {
15691 expect(s.a == 4) catch @panic("test failure");
15692 expect(s.b == 5) catch @panic("test failure");
15693 expect(s.c == 6) catch @panic("test failure");
15694 expect(i == 7) catch @panic("test failure");
15695}
15696
15697extern fn c_ret_struct_u32_u32_u32() Struct_u32_u32_u32;
15698extern fn c_struct_u32_u32_u32(Struct_u32_u32_u32, usize) void;
15699extern fn c_test_struct_u32_u32_u32() void;
15700
15701test "struct u32, u32, u32" {
15702 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15703 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15704 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15705 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15706
15707 const s = c_ret_struct_u32_u32_u32();
15708 try expect(s.a == 8);
15709 try expect(s.b == 9);
15710 try expect(s.c == 10);
15711 c_struct_u32_u32_u32(.{ .a = 11, .b = 12, .c = 13 }, 14);
15712 c_test_struct_u32_u32_u32();
15713}
15714
15715const Struct_u32_u32_u32_u32 = extern struct {
15716 a: u32,
15717 b: u32,
15718 c: u32,
15719 d: u32,
15720};
15721
15722export fn zig_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32 {
15723 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
15724}
15725export fn zig_struct_u32_u32_u32_u32(s: Struct_u32_u32_u32_u32, i: usize) void {
15726 expect(s.a == 5) catch @panic("test failure");
15727 expect(s.b == 6) catch @panic("test failure");
15728 expect(s.c == 7) catch @panic("test failure");
15729 expect(s.d == 8) catch @panic("test failure");
15730 expect(i == 9) catch @panic("test failure");
15731}
15732
15733extern fn c_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32;
15734extern fn c_struct_u32_u32_u32_u32(Struct_u32_u32_u32_u32, usize) void;
15735extern fn c_test_struct_u32_u32_u32_u32() void;
15736
15737test "struct u32, u32, u32, u32" {
15738 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15739 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15740 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15741 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15742
15743 const s = c_ret_struct_u32_u32_u32_u32();
15744 try expect(s.a == 10);
15745 try expect(s.b == 11);
15746 try expect(s.c == 12);
15747 try expect(s.d == 13);
15748 c_struct_u32_u32_u32_u32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
15749 c_test_struct_u32_u32_u32_u32();
15750}
15751
15752const Struct_u64 = extern struct {
15753 a: u64,
15754};
15755
15756export fn zig_ret_struct_u64() Struct_u64 {
15757 return .{ .a = 1 };
15758}
15759export fn zig_struct_u64(s: Struct_u64, i: usize) void {
15760 expect(s.a == 2) catch @panic("test failure");
15761 expect(i == 3) catch @panic("test failure");
15762}
15763
15764extern fn c_ret_struct_u64() Struct_u64;
15765extern fn c_struct_u64(Struct_u64, usize) void;
15766extern fn c_test_struct_u64() void;
15767
15768test "struct u64" {
15769 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15770 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
15771 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15772
15773 const s = c_ret_struct_u64();
15774 try expect(s.a == 4);
15775 c_struct_u64(.{ .a = 5 }, 6);
15776 c_test_struct_u64();
15777}
15778
15779const Struct_u64_u64 = extern struct {
15780 a: u64,
15781 b: u64,
15782};
15783
15784export fn zig_ret_struct_u64_u64() Struct_u64_u64 {
15785 return .{ .a = 1, .b = 2 };
15786}
15787export fn zig_struct_u64_u64(s: Struct_u64_u64, i: usize) void {
15788 expect(s.a == 3) catch @panic("test failure");
15789 expect(s.b == 4) catch @panic("test failure");
15790 expect(i == 1) catch @panic("test failure");
15791}
15792export fn zig_1_struct_u64_u64(_: usize, s: Struct_u64_u64, i: usize) void {
15793 expect(s.a == 5) catch @panic("test failure");
15794 expect(s.b == 6) catch @panic("test failure");
15795 expect(i == 2) catch @panic("test failure");
15796}
15797export fn zig_2_struct_u64_u64(_: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15798 expect(s.a == 7) catch @panic("test failure");
15799 expect(s.b == 8) catch @panic("test failure");
15800 expect(i == 3) catch @panic("test failure");
15801}
15802export fn zig_3_struct_u64_u64(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15803 expect(s.a == 9) catch @panic("test failure");
15804 expect(s.b == 10) catch @panic("test failure");
15805 expect(i == 4) catch @panic("test failure");
15806}
15807export fn zig_4_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15808 expect(s.a == 11) catch @panic("test failure");
15809 expect(s.b == 12) catch @panic("test failure");
15810 expect(i == 5) catch @panic("test failure");
15811}
15812export fn zig_5_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15813 expect(s.a == 13) catch @panic("test failure");
15814 expect(s.b == 14) catch @panic("test failure");
15815 expect(i == 6) catch @panic("test failure");
15816}
15817export fn zig_6_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15818 expect(s.a == 15) catch @panic("test failure");
15819 expect(s.b == 16) catch @panic("test failure");
15820 expect(i == 7) catch @panic("test failure");
15821}
15822export fn zig_7_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15823 expect(s.a == 17) catch @panic("test failure");
15824 expect(s.b == 18) catch @panic("test failure");
15825 expect(i == 8) catch @panic("test failure");
15826}
15827export fn zig_8_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
15828 expect(s.a == 19) catch @panic("test failure");
15829 expect(s.b == 20) catch @panic("test failure");
15830 expect(i == 9) catch @panic("test failure");
15831}
15832
15833extern fn c_ret_struct_u64_u64() Struct_u64_u64;
15834extern fn c_struct_u64_u64(Struct_u64_u64, usize) void;
15835extern fn c_1_struct_u64_u64(usize, Struct_u64_u64, usize) void;
15836extern fn c_2_struct_u64_u64(usize, usize, Struct_u64_u64, usize) void;
15837extern fn c_3_struct_u64_u64(usize, usize, usize, Struct_u64_u64, usize) void;
15838extern fn c_4_struct_u64_u64(usize, usize, usize, usize, Struct_u64_u64, usize) void;
15839extern fn c_5_struct_u64_u64(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
15840extern fn c_6_struct_u64_u64(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
15841extern fn c_7_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
15842extern fn c_8_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
15843extern fn c_test_struct_u64_u64() void;
15844
15845test "struct u64, u64" {
15846 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15847 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15848
15849 const s = c_ret_struct_u64_u64();
15850 try expect(s.a == 21);
15851 try expect(s.b == 22);
15852 c_struct_u64_u64(.{ .a = 23, .b = 24 }, 1);
15853 c_1_struct_u64_u64(0, .{ .a = 25, .b = 26 }, 2);
15854 c_2_struct_u64_u64(0, 1, .{ .a = 27, .b = 28 }, 3);
15855 c_3_struct_u64_u64(0, 1, 2, .{ .a = 29, .b = 30 }, 4);
15856 c_4_struct_u64_u64(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5);
15857 c_5_struct_u64_u64(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6);
15858 c_6_struct_u64_u64(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7);
15859 c_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8);
15860 c_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9);
15861 c_test_struct_u64_u64();
15862}
15863
15864const Struct_u64_u64_u64 = extern struct {
15865 a: u64,
15866 b: u64,
15867 c: u64,
15868};
15869
15870export fn zig_ret_struct_u64_u64_u64() Struct_u64_u64_u64 {
15871 return .{ .a = 1, .b = 2, .c = 3 };
15872}
15873export fn zig_struct_u64_u64_u64(s: Struct_u64_u64_u64, i: usize) void {
15874 expect(s.a == 4) catch @panic("test failure");
15875 expect(s.b == 5) catch @panic("test failure");
15876 expect(s.c == 6) catch @panic("test failure");
15877 expect(i == 7) catch @panic("test failure");
15878}
15879
15880extern fn c_ret_struct_u64_u64_u64() Struct_u64_u64_u64;
15881extern fn c_struct_u64_u64_u64(Struct_u64_u64_u64, usize) void;
15882extern fn c_test_struct_u64_u64_u64() void;
15883
15884test "struct u64, u64, u64" {
15885 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15886 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15887 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15888
15889 const s = c_ret_struct_u64_u64_u64();
15890 try expect(s.a == 8);
15891 try expect(s.b == 9);
15892 try expect(s.c == 10);
15893 c_struct_u64_u64_u64(.{ .a = 11, .b = 12, .c = 13 }, 14);
15894 c_test_struct_u64_u64_u64();
15895}
15896
15897const Struct_u64_u64_u64_u64 = extern struct {
15898 a: u64,
15899 b: u64,
15900 c: u64,
15901 d: u64,
15902};
15903
15904export fn zig_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64 {
15905 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
15906}
15907export fn zig_struct_u64_u64_u64_u64(s: Struct_u64_u64_u64_u64, i: usize) void {
15908 expect(s.a == 5) catch @panic("test failure");
15909 expect(s.b == 6) catch @panic("test failure");
15910 expect(s.c == 7) catch @panic("test failure");
15911 expect(s.d == 8) catch @panic("test failure");
15912 expect(i == 9) catch @panic("test failure");
15913}
15914
15915extern fn c_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64;
15916extern fn c_struct_u64_u64_u64_u64(Struct_u64_u64_u64_u64, usize) void;
15917extern fn c_test_struct_u64_u64_u64_u64() void;
15918
15919test "struct u64, u64, u64, u64" {
15920 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
15921 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15922 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
15923
15924 const s = c_ret_struct_u64_u64_u64_u64();
15925 try expect(s.a == 10);
15926 try expect(s.b == 11);
15927 try expect(s.c == 12);
15928 try expect(s.d == 13);
15929 c_struct_u64_u64_u64_u64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
15930 c_test_struct_u64_u64_u64_u64();
15931}
15932
15933const Struct_f32 = extern struct {
15934 a: f32,
15935};
15936
15937export fn zig_ret_struct_f32() Struct_f32 {
15938 return .{ .a = 1 };
15939}
15940export fn zig_struct_f32(s: Struct_f32, i: usize) void {
15941 expect(s.a == 2) catch @panic("test failure");
15942 expect(i == 3) catch @panic("test failure");
15943}
15944
15945extern fn c_ret_struct_f32() Struct_f32;
15946extern fn c_struct_f32(Struct_f32, usize) void;
15947extern fn c_test_struct_f32() void;
15948
15949test "struct f32" {
15950 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15951 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
15952 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15953
15954 const s = c_ret_struct_f32();
15955 try expect(s.a == 4);
15956 c_struct_f32(.{ .a = 5 }, 6);
15957 c_test_struct_f32();
15958}
15959
15960const Struct_f32_f32 = extern struct {
15961 a: f32,
15962 b: f32,
15963};
15964
15965export fn zig_ret_struct_f32_f32() Struct_f32_f32 {
15966 return .{ .a = 1, .b = 2 };
15967}
15968export fn zig_struct_f32_f32(s: Struct_f32_f32, i: usize) void {
15969 expect(s.a == 3) catch @panic("test failure");
15970 expect(s.b == 4) catch @panic("test failure");
15971 expect(i == 5) catch @panic("test failure");
15972}
15973
15974extern fn c_ret_struct_f32_f32() Struct_f32_f32;
15975extern fn c_struct_f32_f32(Struct_f32_f32, usize) void;
15976extern fn c_test_struct_f32_f32() void;
15977
15978test "struct f32, f32" {
15979 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
15980 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
15981 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
15982 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
15983 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
15984 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
15985
15986 const s = c_ret_struct_f32_f32();
15987 try expect(s.a == 6);
15988 try expect(s.b == 7);
15989 c_struct_f32_f32(.{ .a = 8, .b = 9 }, 10);
15990 c_test_struct_f32_f32();
15991}
15992
15993const Struct_f32_f32_f32 = extern struct {
15994 a: f32,
15995 b: f32,
15996 c: f32,
15997};
15998
15999export fn zig_ret_struct_f32_f32_f32() Struct_f32_f32_f32 {
16000 return .{ .a = 1, .b = 2, .c = 3 };
16001}
16002export fn zig_struct_f32_f32_f32(s: Struct_f32_f32_f32, i: usize) void {
16003 expect(s.a == 4) catch @panic("test failure");
16004 expect(s.b == 5) catch @panic("test failure");
16005 expect(s.c == 6) catch @panic("test failure");
16006 expect(i == 7) catch @panic("test failure");
16007}
16008
16009extern fn c_ret_struct_f32_f32_f32() Struct_f32_f32_f32;
16010extern fn c_struct_f32_f32_f32(Struct_f32_f32_f32, usize) void;
16011extern fn c_test_struct_f32_f32_f32() void;
16012
16013test "struct f32, f32, f32" {
16014 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16015 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16016 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16017 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16018 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16019
16020 const s = c_ret_struct_f32_f32_f32();
16021 try expect(s.a == 8);
16022 try expect(s.b == 9);
16023 try expect(s.c == 10);
16024 c_struct_f32_f32_f32(.{ .a = 11, .b = 12, .c = 13 }, 14);
16025 c_test_struct_f32_f32_f32();
16026}
16027
16028const Struct_f32_f32_f32_f32 = extern struct {
16029 a: f32,
16030 b: f32,
16031 c: f32,
16032 d: f32,
16033};
16034
16035export fn zig_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32 {
16036 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
16037}
16038export fn zig_struct_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32, i: usize) void {
16039 expect(s.a == 5) catch @panic("test failure");
16040 expect(s.b == 6) catch @panic("test failure");
16041 expect(s.c == 7) catch @panic("test failure");
16042 expect(s.d == 8) catch @panic("test failure");
16043 expect(i == 9) catch @panic("test failure");
16044}
16045
16046extern fn c_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32;
16047extern fn c_struct_f32_f32_f32_f32(Struct_f32_f32_f32_f32, usize) void;
16048extern fn c_test_struct_f32_f32_f32_f32() void;
16049
16050test "struct f32, f32, f32, f32" {
16051 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16052 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16053 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16054 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16055 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16056
16057 const s = c_ret_struct_f32_f32_f32_f32();
16058 try expect(s.a == 10);
16059 try expect(s.b == 11);
16060 try expect(s.c == 12);
16061 try expect(s.d == 13);
16062 c_struct_f32_f32_f32_f32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
16063 c_test_struct_f32_f32_f32_f32();
16064}
16065
16066const Struct_f32_f32_f32_f32_f32 = extern struct {
16067 a: f32,
16068 b: f32,
16069 c: f32,
16070 d: f32,
16071 e: f32,
16072};
16073
16074export fn zig_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32 {
16075 return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 };
16076}
16077export fn zig_struct_f32_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32_f32, i: usize) void {
16078 expect(s.a == 6) catch @panic("test failure");
16079 expect(s.b == 7) catch @panic("test failure");
16080 expect(s.c == 8) catch @panic("test failure");
16081 expect(s.d == 9) catch @panic("test failure");
16082 expect(s.e == 10) catch @panic("test failure");
16083 expect(i == 11) catch @panic("test failure");
16084}
16085
16086extern fn c_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32;
16087extern fn c_struct_f32_f32_f32_f32_f32(Struct_f32_f32_f32_f32_f32, usize) void;
16088extern fn c_test_struct_f32_f32_f32_f32_f32() void;
16089
16090test "struct f32, f32, f32, f32, f32" {
16091 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16092 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16093 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16094 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16095
16096 const s = c_ret_struct_f32_f32_f32_f32_f32();
16097 try expect(s.a == 12);
16098 try expect(s.b == 13);
16099 try expect(s.c == 14);
16100 try expect(s.d == 15);
16101 try expect(s.e == 16);
16102 c_struct_f32_f32_f32_f32_f32(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22);
16103 c_test_struct_f32_f32_f32_f32_f32();
16104}
16105
16106const Struct_void_f32 = extern struct {
16107 _: void = {},
16108 a: f32,
16109};
16110
16111export fn zig_ret_struct_void_f32() Struct_void_f32 {
16112 return .{ .a = 1 };
16113}
16114export fn zig_struct_void_f32(s: Struct_void_f32, i: usize) void {
16115 expect(s.a == 2) catch @panic("test failure");
16116 expect(i == 3) catch @panic("test failure");
16117}
16118
16119extern fn c_ret_struct_void_f32() Struct_void_f32;
16120extern fn c_struct_void_f32(Struct_void_f32, usize) void;
16121extern fn c_test_struct_void_f32() void;
16122
16123test "struct void, f32" {
16124 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16125 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16126 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
16127
16128 const s = c_ret_struct_void_f32();
16129 try expect(s.a == 4);
16130 c_struct_void_f32(.{ .a = 5 }, 6);
16131 c_test_struct_void_f32();
16132}
16133
16134const Struct_array_1_f32 = extern struct {
16135 a: [1]f32,
16136};
16137
16138export fn zig_ret_struct_array_1_f32() Struct_array_1_f32 {
16139 return .{ .a = .{1} };
16140}
16141export fn zig_struct_array_1_f32(s: Struct_array_1_f32, i: usize) void {
16142 expect(s.a[0] == 2) catch @panic("test failure");
16143 expect(i == 3) catch @panic("test failure");
16144}
16145
16146extern fn c_ret_struct_array_1_f32() Struct_array_1_f32;
16147extern fn c_struct_array_1_f32(Struct_array_1_f32, usize) void;
16148extern fn c_test_struct_array_1_f32() void;
16149
16150test "struct [1]f32" {
16151 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16152 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16153 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16154 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16155 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16156
16157 const s = c_ret_struct_array_1_f32();
16158 try expect(s.a[0] == 4);
16159 c_struct_array_1_f32(.{ .a = .{5} }, 6);
16160 c_test_struct_array_1_f32();
16161}
16162
16163const Struct_array_2_f32 = extern struct {
16164 a: [2]f32,
16165};
16166
16167export fn zig_ret_struct_array_2_f32() Struct_array_2_f32 {
16168 return .{ .a = .{ 1, 2 } };
16169}
16170export fn zig_struct_array_2_f32(s: Struct_array_2_f32, i: usize) void {
16171 expect(s.a[0] == 3) catch @panic("test failure");
16172 expect(s.a[1] == 4) catch @panic("test failure");
16173 expect(i == 5) catch @panic("test failure");
16174}
16175
16176extern fn c_ret_struct_array_2_f32() Struct_array_2_f32;
16177extern fn c_struct_array_2_f32(Struct_array_2_f32, usize) void;
16178extern fn c_test_struct_array_2_f32() void;
16179
16180test "struct [2]f32" {
16181 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16182 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16183 if (builtin.cpu.arch == .loongarch64 and builtin.abi.float() == .hard) return error.SkipZigTest;
16184 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16185 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16186 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16187
16188 const s = c_ret_struct_array_2_f32();
16189 try expect(s.a[0] == 6);
16190 try expect(s.a[1] == 7);
16191 c_struct_array_2_f32(.{ .a = .{ 8, 9 } }, 10);
16192 c_test_struct_array_2_f32();
16193}
16194
16195const Struct_array_3_f32 = extern struct {
16196 a: [3]f32,
16197};
16198
16199export fn zig_ret_struct_array_3_f32() Struct_array_3_f32 {
16200 return .{ .a = .{ 1, 2, 3 } };
16201}
16202export fn zig_struct_array_3_f32(s: Struct_array_3_f32, i: usize) void {
16203 expect(s.a[0] == 4) catch @panic("test failure");
16204 expect(s.a[1] == 5) catch @panic("test failure");
16205 expect(s.a[2] == 6) catch @panic("test failure");
16206 expect(i == 7) catch @panic("test failure");
16207}
16208
16209extern fn c_ret_struct_array_3_f32() Struct_array_3_f32;
16210extern fn c_struct_array_3_f32(Struct_array_3_f32, usize) void;
16211extern fn c_test_struct_array_3_f32() void;
16212
16213test "struct [3]f32" {
16214 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16215 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16216 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16217 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16218 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16219
16220 const s = c_ret_struct_array_3_f32();
16221 try expect(s.a[0] == 8);
16222 try expect(s.a[1] == 9);
16223 try expect(s.a[2] == 10);
16224 c_struct_array_3_f32(.{ .a = .{ 11, 12, 13 } }, 14);
16225 c_test_struct_array_3_f32();
16226}
16227
16228const Struct_array_4_f32 = extern struct {
16229 a: [4]f32,
16230};
16231
16232export fn zig_ret_struct_array_4_f32() Struct_array_4_f32 {
16233 return .{ .a = .{ 1, 2, 3, 4 } };
16234}
16235export fn zig_struct_array_4_f32(s: Struct_array_4_f32, i: usize) void {
16236 expect(s.a[0] == 5) catch @panic("test failure");
16237 expect(s.a[1] == 6) catch @panic("test failure");
16238 expect(s.a[2] == 7) catch @panic("test failure");
16239 expect(s.a[3] == 8) catch @panic("test failure");
16240 expect(i == 9) catch @panic("test failure");
16241}
16242
16243extern fn c_ret_struct_array_4_f32() Struct_array_4_f32;
16244extern fn c_struct_array_4_f32(Struct_array_4_f32, usize) void;
16245extern fn c_test_struct_array_4_f32() void;
16246
16247test "struct [4]f32" {
16248 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16249 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16250 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16251 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16252 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16253
16254 const s = c_ret_struct_array_4_f32();
16255 try expect(s.a[0] == 10);
16256 try expect(s.a[1] == 11);
16257 try expect(s.a[2] == 12);
16258 try expect(s.a[3] == 13);
16259 c_struct_array_4_f32(.{ .a = .{ 14, 15, 16, 17 } }, 18);
16260 c_test_struct_array_4_f32();
16261}
16262
16263const Struct_array_5_f32 = extern struct {
16264 a: [5]f32,
16265};
16266
16267export fn zig_ret_struct_array_5_f32() Struct_array_5_f32 {
16268 return .{ .a = .{ 1, 2, 3, 4, 5 } };
16269}
16270export fn zig_struct_array_5_f32(s: Struct_array_5_f32, i: usize) void {
16271 expect(s.a[0] == 6) catch @panic("test failure");
16272 expect(s.a[1] == 7) catch @panic("test failure");
16273 expect(s.a[2] == 8) catch @panic("test failure");
16274 expect(s.a[3] == 9) catch @panic("test failure");
16275 expect(s.a[4] == 10) catch @panic("test failure");
16276 expect(i == 11) catch @panic("test failure");
16277}
16278
16279extern fn c_ret_struct_array_5_f32() Struct_array_5_f32;
16280extern fn c_struct_array_5_f32(Struct_array_5_f32, usize) void;
16281extern fn c_test_struct_array_5_f32() void;
16282
16283test "struct [5]f32" {
16284 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16285 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16286 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16287 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16288
16289 const s = c_ret_struct_array_5_f32();
16290 try expect(s.a[0] == 12);
16291 try expect(s.a[1] == 13);
16292 try expect(s.a[2] == 14);
16293 try expect(s.a[3] == 15);
16294 try expect(s.a[4] == 16);
16295 c_struct_array_5_f32(.{ .a = .{ 17, 18, 19, 20, 21 } }, 22);
16296 c_test_struct_array_5_f32();
16297}
16298
16299const Struct_array_0_sentinel_f32 = extern struct {
16300 a: [0:0x1e1]f32,
16301};
16302
16303export fn zig_ret_struct_array_0_sentinel_f32() Struct_array_0_sentinel_f32 {
16304 return .{ .a = .{} };
16305}
16306export fn zig_struct_array_0_sentinel_f32(s: Struct_array_0_sentinel_f32, i: usize) void {
16307 var sentinel_index: usize = 0;
16308 _ = &sentinel_index;
16309 expect(s.a[sentinel_index] == 0x1e1) catch @panic("test failure");
16310 expect(i == 1) catch @panic("test failure");
16311}
16312
16313extern fn c_ret_struct_array_0_sentinel_f32() Struct_array_0_sentinel_f32;
16314extern fn c_struct_array_0_sentinel_f32(Struct_array_0_sentinel_f32, usize) void;
16315extern fn c_test_struct_array_0_sentinel_f32() void;
16316
16317test "struct [0:sentinel]f32" {
16318 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16319 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16320 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16321 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16322 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16323
16324 var sentinel_index: usize = 0;
16325 _ = &sentinel_index;
16326 const s = c_ret_struct_array_0_sentinel_f32();
16327 try expect(s.a[sentinel_index] == 0x1e1);
16328 c_struct_array_0_sentinel_f32(.{ .a = .{} }, 2);
16329 c_test_struct_array_0_sentinel_f32();
16330}
16331
16332const Struct_array_1_sentinel_f32 = extern struct {
16333 a: [1:0x1e1]f32,
16334};
16335
16336export fn zig_ret_struct_array_1_sentinel_f32() Struct_array_1_sentinel_f32 {
16337 return .{ .a = .{1} };
16338}
16339export fn zig_struct_array_1_sentinel_f32(s: Struct_array_1_sentinel_f32, i: usize) void {
16340 var sentinel_index: usize = 1;
16341 _ = &sentinel_index;
16342 expect(s.a[0] == 2) catch @panic("test failure");
16343 expect(s.a[sentinel_index] == 0x1e1) catch @panic("test failure");
16344 expect(i == 3) catch @panic("test failure");
16345}
16346
16347extern fn c_ret_struct_array_1_sentinel_f32() Struct_array_1_sentinel_f32;
16348extern fn c_struct_array_1_sentinel_f32(Struct_array_1_sentinel_f32, usize) void;
16349extern fn c_test_struct_array_1_sentinel_f32() void;
16350
16351test "struct [1:sentinel]f32" {
16352 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16353 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16354 if (builtin.cpu.arch == .loongarch64 and builtin.abi.float() == .hard) return error.SkipZigTest;
16355 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16356 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16357 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16358
16359 var sentinel_index: usize = 1;
16360 _ = &sentinel_index;
16361 const s = c_ret_struct_array_1_sentinel_f32();
16362 try expect(s.a[0] == 4);
16363 try expect(s.a[sentinel_index] == 0x1e1);
16364 c_struct_array_1_sentinel_f32(.{ .a = .{5} }, 6);
16365 c_test_struct_array_1_sentinel_f32();
16366}
16367
16368const Struct_array_2_sentinel_f32 = extern struct {
16369 a: [2:0x1e1]f32,
16370};
16371
16372export fn zig_ret_struct_array_2_sentinel_f32() Struct_array_2_sentinel_f32 {
16373 return .{ .a = .{ 1, 2 } };
16374}
16375export fn zig_struct_array_2_sentinel_f32(s: Struct_array_2_sentinel_f32, i: usize) void {
16376 var sentinel_index: usize = 2;
16377 _ = &sentinel_index;
16378 expect(s.a[0] == 3) catch @panic("test failure");
16379 expect(s.a[1] == 4) catch @panic("test failure");
16380 expect(s.a[sentinel_index] == 0x1e1) catch @panic("test failure");
16381 expect(i == 5) catch @panic("test failure");
16382}
16383
16384extern fn c_ret_struct_array_2_sentinel_f32() Struct_array_2_sentinel_f32;
16385extern fn c_struct_array_2_sentinel_f32(Struct_array_2_sentinel_f32, usize) void;
16386extern fn c_test_struct_array_2_sentinel_f32() void;
16387
16388test "struct [2:sentinel]f32" {
16389 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16390 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16391 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16392 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16393 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16394
16395 var sentinel_index: usize = 2;
16396 _ = &sentinel_index;
16397 const s = c_ret_struct_array_2_sentinel_f32();
16398 try expect(s.a[0] == 6);
16399 try expect(s.a[1] == 7);
16400 try expect(s.a[sentinel_index] == 0x1e1);
16401 c_struct_array_2_sentinel_f32(.{ .a = .{ 8, 9 } }, 10);
16402 c_test_struct_array_2_sentinel_f32();
16403}
16404
16405const Struct_array_3_sentinel_f32 = extern struct {
16406 a: [3:0x1e1]f32,
16407};
16408
16409export fn zig_ret_struct_array_3_sentinel_f32() Struct_array_3_sentinel_f32 {
16410 return .{ .a = .{ 1, 2, 3 } };
16411}
16412export fn zig_struct_array_3_sentinel_f32(s: Struct_array_3_sentinel_f32, i: usize) void {
16413 var sentinel_index: usize = 3;
16414 _ = &sentinel_index;
16415 expect(s.a[0] == 4) catch @panic("test failure");
16416 expect(s.a[1] == 5) catch @panic("test failure");
16417 expect(s.a[2] == 6) catch @panic("test failure");
16418 expect(s.a[sentinel_index] == 0x1e1) catch @panic("test failure");
16419 expect(i == 7) catch @panic("test failure");
16420}
16421
16422extern fn c_ret_struct_array_3_sentinel_f32() Struct_array_3_sentinel_f32;
16423extern fn c_struct_array_3_sentinel_f32(Struct_array_3_sentinel_f32, usize) void;
16424extern fn c_test_struct_array_3_sentinel_f32() void;
16425
16426test "struct [3:sentinel]f32" {
16427 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16428 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16429 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16430 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16431 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16432
16433 var sentinel_index: usize = 3;
16434 _ = &sentinel_index;
16435 const s = c_ret_struct_array_3_sentinel_f32();
16436 try expect(s.a[0] == 8);
16437 try expect(s.a[1] == 9);
16438 try expect(s.a[2] == 10);
16439 try expect(s.a[sentinel_index] == 0x1e1);
16440 c_struct_array_3_sentinel_f32(.{ .a = .{ 11, 12, 13 } }, 14);
16441 c_test_struct_array_3_sentinel_f32();
16442}
16443
16444const Struct_array_4_sentinel_f32 = extern struct {
16445 a: [4:0x1e1]f32,
16446};
16447
16448export fn zig_ret_struct_array_4_sentinel_f32() Struct_array_4_sentinel_f32 {
16449 return .{ .a = .{ 1, 2, 3, 4 } };
16450}
16451export fn zig_struct_array_4_sentinel_f32(s: Struct_array_4_sentinel_f32, i: usize) void {
16452 var sentinel_index: usize = 4;
16453 _ = &sentinel_index;
16454 expect(s.a[0] == 5) catch @panic("test failure");
16455 expect(s.a[1] == 6) catch @panic("test failure");
16456 expect(s.a[2] == 7) catch @panic("test failure");
16457 expect(s.a[3] == 8) catch @panic("test failure");
16458 expect(s.a[sentinel_index] == 0x1e1) catch @panic("test failure");
16459 expect(i == 9) catch @panic("test failure");
16460}
16461
16462extern fn c_ret_struct_array_4_sentinel_f32() Struct_array_4_sentinel_f32;
16463extern fn c_struct_array_4_sentinel_f32(Struct_array_4_sentinel_f32, usize) void;
16464extern fn c_test_struct_array_4_sentinel_f32() void;
16465
16466test "struct [4:sentinel]f32" {
16467 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16468 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16469 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16470 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16471
16472 var sentinel_index: usize = 4;
16473 _ = &sentinel_index;
16474 const s = c_ret_struct_array_4_sentinel_f32();
16475 try expect(s.a[0] == 10);
16476 try expect(s.a[1] == 11);
16477 try expect(s.a[2] == 12);
16478 try expect(s.a[3] == 13);
16479 try expect(s.a[sentinel_index] == 0x1e1);
16480 c_struct_array_4_sentinel_f32(.{ .a = .{ 14, 15, 16, 17 } }, 18);
16481 c_test_struct_array_4_sentinel_f32();
16482}
16483
16484const Struct_f32a8 = extern struct {
16485 a: f32 align(8),
16486};
16487
16488export fn zig_ret_struct_f32a8() Struct_f32a8 {
16489 return .{ .a = 1.25 };
16490}
16491export fn zig_struct_f32a8(s: Struct_f32a8, f: f32) void {
16492 expect(s.a == 2.75) catch @panic("test failure");
16493 expect(f == 3.5) catch @panic("test failure");
16494}
16495
16496extern fn c_ret_struct_f32a8() Struct_f32a8;
16497extern fn c_struct_f32a8(Struct_f32a8, f32) void;
16498extern fn c_test_struct_f32a8() void;
16499
16500test "struct f32 align(8)" {
16501 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16502 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16503 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16504 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16505 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16506 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
16507 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
16508
16509 const s = c_ret_struct_f32a8();
16510 try expect(s.a == 4.125);
16511 c_struct_f32a8(.{ .a = 5.375 }, 6.5);
16512 c_test_struct_f32a8();
16513}
16514
16515const Struct_f32a8_f32a8 = extern struct {
16516 a: f32 align(8),
16517 b: f32 align(8),
16518};
16519
16520export fn zig_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8 {
16521 return .{ .a = 1.25, .b = 2.75 };
16522}
16523export fn zig_struct_f32a8_f32a8(s: Struct_f32a8_f32a8, f: f32) void {
16524 expect(s.a == 3.125) catch @panic("test failure");
16525 expect(s.b == 4.375) catch @panic("test failure");
16526 expect(f == 5.5) catch @panic("test failure");
16527}
16528
16529extern fn c_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8;
16530extern fn c_struct_f32a8_f32a8(Struct_f32a8_f32a8, f32) void;
16531extern fn c_test_struct_f32a8_f32a8() void;
16532
16533test "struct f32 align(8), f32 align(8)" {
16534 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16535 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16536 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16537 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16538 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16539 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16540 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
16541
16542 const s = c_ret_struct_f32a8_f32a8();
16543 try expect(s.a == 6.625);
16544 try expect(s.b == 7.875);
16545 c_struct_f32a8_f32a8(.{ .a = 8.0625, .b = 9.1875 }, 10.5);
16546 c_test_struct_f32a8_f32a8();
16547}
16548
16549const Struct_f32f32_f32 = extern struct {
16550 a: extern struct { b: f32, c: f32 },
16551 d: f32,
16552};
16553
16554export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 {
16555 return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 };
16556}
16557export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void {
16558 expect(s.a.b == 1.0) catch @panic("test failure");
16559 expect(s.a.c == 2.0) catch @panic("test failure");
16560 expect(s.d == 3.0) catch @panic("test failure");
16561}
16562
16563extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32;
16564extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void;
16565extern fn c_test_struct_f32f32_f32() void;
16566
16567test "struct {f32, f32}, f32" {
16568 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16569 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16570 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16571 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16572 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16573
16574 const s = c_ret_struct_f32f32_f32();
16575 try expect(s.a.b == 1.0);
16576 try expect(s.a.c == 2.0);
16577 try expect(s.d == 3.0);
16578 c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 });
16579 c_test_struct_f32f32_f32();
16580}
16581
16582const Struct_f32_f32f32 = extern struct {
16583 a: f32,
16584 b: extern struct { c: f32, d: f32 },
16585};
16586
16587export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 {
16588 return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } };
16589}
16590export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void {
16591 expect(s.a == 1.0) catch @panic("test failure");
16592 expect(s.b.c == 2.0) catch @panic("test failure");
16593 expect(s.b.d == 3.0) catch @panic("test failure");
16594}
16595
16596extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32;
16597extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void;
16598extern fn c_test_struct_f32_f32f32() void;
16599
16600test "struct f32, {f32, f32}" {
16601 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16602 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16603 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16604 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16605 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16606
16607 const s = c_ret_struct_f32_f32f32();
16608 try expect(s.a == 1.0);
16609 try expect(s.b.c == 2.0);
16610 try expect(s.b.d == 3.0);
16611 c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } });
16612 c_test_struct_f32_f32f32();
16613}
16614
16615const Struct_f64 = extern struct {
16616 a: f64,
16617};
16618
16619export fn zig_ret_struct_f64() Struct_f64 {
16620 return .{ .a = 1 };
16621}
16622export fn zig_struct_f64(s: Struct_f64, i: usize) void {
16623 expect(s.a == 2) catch @panic("test failure");
16624 expect(i == 3) catch @panic("test failure");
16625}
16626
16627extern fn c_ret_struct_f64() Struct_f64;
16628extern fn c_struct_f64(Struct_f64, usize) void;
16629extern fn c_test_struct_f64() void;
16630
16631test "struct f64" {
16632 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16633 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16634 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
16635 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
16636
16637 const s = c_ret_struct_f64();
16638 try expect(s.a == 4);
16639 c_struct_f64(.{ .a = 5 }, 6);
16640 c_test_struct_f64();
16641}
16642
16643const Struct_f64_f64 = extern struct {
16644 a: f64,
16645 b: f64,
16646};
16647
16648export fn zig_ret_struct_f64_f64() Struct_f64_f64 {
16649 return .{ .a = 1, .b = 2 };
16650}
16651export fn zig_struct_f64_f64(s: Struct_f64_f64, i: usize) void {
16652 expect(s.a == 3) catch @panic("test failure");
16653 expect(s.b == 4) catch @panic("test failure");
16654 expect(i == 5) catch @panic("test failure");
16655}
16656
16657extern fn c_ret_struct_f64_f64() Struct_f64_f64;
16658extern fn c_struct_f64_f64(Struct_f64_f64, usize) void;
16659extern fn c_test_struct_f64_f64() void;
16660
16661test "struct f64, f64" {
16662 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16663 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16664 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16665
16666 const s = c_ret_struct_f64_f64();
16667 try expect(s.a == 6);
16668 try expect(s.b == 7);
16669 c_struct_f64_f64(.{ .a = 8, .b = 9 }, 10);
16670 c_test_struct_f64_f64();
16671}
16672
16673const Struct_f64_f64_f64 = extern struct {
16674 a: f64,
16675 b: f64,
16676 c: f64,
16677};
16678
16679export fn zig_ret_struct_f64_f64_f64() Struct_f64_f64_f64 {
16680 return .{ .a = 1, .b = 2, .c = 3 };
16681}
16682export fn zig_struct_f64_f64_f64(s: Struct_f64_f64_f64, i: usize) void {
16683 expect(s.a == 4) catch @panic("test failure");
16684 expect(s.b == 5) catch @panic("test failure");
16685 expect(s.c == 6) catch @panic("test failure");
16686 expect(i == 7) catch @panic("test failure");
16687}
16688
16689extern fn c_ret_struct_f64_f64_f64() Struct_f64_f64_f64;
16690extern fn c_struct_f64_f64_f64(Struct_f64_f64_f64, usize) void;
16691extern fn c_test_struct_f64_f64_f64() void;
16692
16693test "struct f64, f64, f64" {
16694 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16695 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16696 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16697
16698 const s = c_ret_struct_f64_f64_f64();
16699 try expect(s.a == 8);
16700 try expect(s.b == 9);
16701 try expect(s.c == 10);
16702 c_struct_f64_f64_f64(.{ .a = 11, .b = 12, .c = 13 }, 14);
16703 c_test_struct_f64_f64_f64();
16704}
16705
16706const Struct_f64_f64_f64_f64 = extern struct {
16707 a: f64,
16708 b: f64,
16709 c: f64,
16710 d: f64,
16711};
16712
16713export fn zig_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64 {
16714 return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
16715}
16716export fn zig_struct_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64, i: usize) void {
16717 expect(s.a == 5) catch @panic("test failure");
16718 expect(s.b == 6) catch @panic("test failure");
16719 expect(s.c == 7) catch @panic("test failure");
16720 expect(s.d == 8) catch @panic("test failure");
16721 expect(i == 9) catch @panic("test failure");
16722}
16723
16724extern fn c_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64;
16725extern fn c_struct_f64_f64_f64_f64(Struct_f64_f64_f64_f64, usize) void;
16726extern fn c_test_struct_f64_f64_f64_f64() void;
16727
16728test "struct f64, f64, f64, f64" {
16729 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16730 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16731 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16732
16733 const s = c_ret_struct_f64_f64_f64_f64();
16734 try expect(s.a == 10);
16735 try expect(s.b == 11);
16736 try expect(s.c == 12);
16737 try expect(s.d == 13);
16738 c_struct_f64_f64_f64_f64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
16739 c_test_struct_f64_f64_f64_f64();
16740}
16741
16742const Struct_f64_f64_f64_f64_f64 = extern struct {
16743 a: f64,
16744 b: f64,
16745 c: f64,
16746 d: f64,
16747 e: f64,
16748};
16749
16750export fn zig_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64 {
16751 return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 };
16752}
16753export fn zig_struct_f64_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64_f64, i: usize) void {
16754 expect(s.a == 6) catch @panic("test failure");
16755 expect(s.b == 7) catch @panic("test failure");
16756 expect(s.c == 8) catch @panic("test failure");
16757 expect(s.d == 9) catch @panic("test failure");
16758 expect(s.e == 10) catch @panic("test failure");
16759 expect(i == 11) catch @panic("test failure");
16760}
16761
16762extern fn c_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64;
16763extern fn c_struct_f64_f64_f64_f64_f64(Struct_f64_f64_f64_f64_f64, usize) void;
16764extern fn c_test_struct_f64_f64_f64_f64_f64() void;
16765
16766test "struct f64, f64, f64, f64, f64" {
16767 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16768 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
16769 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16770
16771 const s = c_ret_struct_f64_f64_f64_f64_f64();
16772 try expect(s.a == 12);
16773 try expect(s.b == 13);
16774 try expect(s.c == 14);
16775 try expect(s.d == 15);
16776 try expect(s.e == 16);
16777 c_struct_f64_f64_f64_f64_f64(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22);
16778 c_test_struct_f64_f64_f64_f64_f64();
16779}
16780
16781const Struct_array_1_f64 = extern struct {
16782 a: [1]f64,
16783};
16784
16785export fn zig_ret_struct_array_1_f64() Struct_array_1_f64 {
16786 return .{ .a = .{1} };
16787}
16788export fn zig_struct_array_1_f64(s: Struct_array_1_f64, i: usize) void {
16789 expect(s.a[0] == 2) catch @panic("test failure");
16790 expect(i == 3) catch @panic("test failure");
16791}
16792
16793extern fn c_ret_struct_array_1_f64() Struct_array_1_f64;
16794extern fn c_struct_array_1_f64(Struct_array_1_f64, usize) void;
16795extern fn c_test_struct_array_1_f64() void;
16796
16797test "struct [1]f64" {
16798 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16799 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16800 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16801 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16802 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16803
16804 const s = c_ret_struct_array_1_f64();
16805 try expect(s.a[0] == 4);
16806 c_struct_array_1_f64(.{ .a = .{5} }, 6);
16807 c_test_struct_array_1_f64();
16808}
16809
16810const Struct_array_2_f64 = extern struct {
16811 a: [2]f64,
16812};
16813
16814export fn zig_ret_struct_array_2_f64() Struct_array_2_f64 {
16815 return .{ .a = .{ 1, 2 } };
16816}
16817export fn zig_struct_array_2_f64(s: Struct_array_2_f64, i: usize) void {
16818 expect(s.a[0] == 3) catch @panic("test failure");
16819 expect(s.a[1] == 4) catch @panic("test failure");
16820 expect(i == 5) catch @panic("test failure");
16821}
16822
16823extern fn c_ret_struct_array_2_f64() Struct_array_2_f64;
16824extern fn c_struct_array_2_f64(Struct_array_2_f64, usize) void;
16825extern fn c_test_struct_array_2_f64() void;
16826
16827test "struct [2]f64" {
16828 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16829 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16830 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16831 if (builtin.cpu.arch == .loongarch64 and builtin.abi.float() == .hard) return error.SkipZigTest;
16832 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16833 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16834 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
16835
16836 const s = c_ret_struct_array_2_f64();
16837 try expect(s.a[0] == 6);
16838 try expect(s.a[1] == 7);
16839 c_struct_array_2_f64(.{ .a = .{ 8, 9 } }, 10);
16840 c_test_struct_array_2_f64();
16841}
16842
16843const Struct_array_3_f64 = extern struct {
16844 a: [3]f64,
16845};
16846
16847export fn zig_ret_struct_array_3_f64() Struct_array_3_f64 {
16848 return .{ .a = .{ 1, 2, 3 } };
16849}
16850export fn zig_struct_array_3_f64(s: Struct_array_3_f64, i: usize) void {
16851 expect(s.a[0] == 4) catch @panic("test failure");
16852 expect(s.a[1] == 5) catch @panic("test failure");
16853 expect(s.a[2] == 6) catch @panic("test failure");
16854 expect(i == 7) catch @panic("test failure");
16855}
16856
16857extern fn c_ret_struct_array_3_f64() Struct_array_3_f64;
16858extern fn c_struct_array_3_f64(Struct_array_3_f64, usize) void;
16859extern fn c_test_struct_array_3_f64() void;
16860
16861test "struct [3]f64" {
16862 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16863 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16864 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16865 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16866 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16867
16868 const s = c_ret_struct_array_3_f64();
16869 try expect(s.a[0] == 8);
16870 try expect(s.a[1] == 9);
16871 try expect(s.a[2] == 10);
16872 c_struct_array_3_f64(.{ .a = .{ 11, 12, 13 } }, 14);
16873 c_test_struct_array_3_f64();
16874}
16875
16876const Struct_array_4_f64 = extern struct {
16877 a: [4]f64,
16878};
16879
16880export fn zig_ret_struct_array_4_f64() Struct_array_4_f64 {
16881 return .{ .a = .{ 1, 2, 3, 4 } };
16882}
16883export fn zig_struct_array_4_f64(s: Struct_array_4_f64, i: usize) void {
16884 expect(s.a[0] == 5) catch @panic("test failure");
16885 expect(s.a[1] == 6) catch @panic("test failure");
16886 expect(s.a[2] == 7) catch @panic("test failure");
16887 expect(s.a[3] == 8) catch @panic("test failure");
16888 expect(i == 9) catch @panic("test failure");
16889}
16890
16891extern fn c_ret_struct_array_4_f64() Struct_array_4_f64;
16892extern fn c_struct_array_4_f64(Struct_array_4_f64, usize) void;
16893extern fn c_test_struct_array_4_f64() void;
16894
16895test "struct [4]f64" {
16896 if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
16897 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
16898 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16899 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16900 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16901
16902 const s = c_ret_struct_array_4_f64();
16903 try expect(s.a[0] == 10);
16904 try expect(s.a[1] == 11);
16905 try expect(s.a[2] == 12);
16906 try expect(s.a[3] == 13);
16907 c_struct_array_4_f64(.{ .a = .{ 14, 15, 16, 17 } }, 18);
16908 c_test_struct_array_4_f64();
16909}
16910
16911const Struct_array_5_f64 = extern struct {
16912 a: [5]f64,
16913};
16914
16915export fn zig_ret_struct_array_5_f64() Struct_array_5_f64 {
16916 return .{ .a = .{ 1, 2, 3, 4, 5 } };
16917}
16918export fn zig_struct_array_5_f64(s: Struct_array_5_f64, i: usize) void {
16919 expect(s.a[0] == 6) catch @panic("test failure");
16920 expect(s.a[1] == 7) catch @panic("test failure");
16921 expect(s.a[2] == 8) catch @panic("test failure");
16922 expect(s.a[3] == 9) catch @panic("test failure");
16923 expect(s.a[4] == 10) catch @panic("test failure");
16924 expect(i == 11) catch @panic("test failure");
16925}
16926
16927extern fn c_ret_struct_array_5_f64() Struct_array_5_f64;
16928extern fn c_struct_array_5_f64(Struct_array_5_f64, usize) void;
16929extern fn c_test_struct_array_5_f64() void;
16930
16931test "struct [5]f64" {
16932 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
16933 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
16934 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16935
16936 const s = c_ret_struct_array_5_f64();
16937 try expect(s.a[0] == 12);
16938 try expect(s.a[1] == 13);
16939 try expect(s.a[2] == 14);
16940 try expect(s.a[3] == 15);
16941 try expect(s.a[4] == 16);
16942 c_struct_array_5_f64(.{ .a = .{ 17, 18, 19, 20, 21 } }, 22);
16943 c_test_struct_array_5_f64();
16944}
16945
16946const Union_f64 = extern union {
16947 a: f64,
16948};
16949
16950export fn zig_ret_union_f64() Union_f64 {
16951 return .{ .a = 1 };
16952}
16953export fn zig_union_f64(s: Union_f64, i: usize) void {
16954 expect(s.a == 2) catch @panic("test failure");
16955 expect(i == 3) catch @panic("test failure");
16956}
16957
16958extern fn c_ret_union_f64() Union_f64;
16959extern fn c_union_f64(Union_f64, usize) void;
16960extern fn c_test_union_f64() void;
16961
16962test "union f64" {
16963 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
16964 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
16965 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
16966 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
16967 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
16968 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
16969
16970 const s = c_ret_union_f64();
16971 try expect(s.a == 4);
16972 c_union_f64(.{ .a = 5 }, 6);
16973 c_test_union_f64();
16974}
16975
16976const Struct_u32_Union_u32_u32u32 = extern struct {
16977 a: u32,
16978 b: extern union {
16979 c: extern struct {
16980 d: u32,
16981 e: u32,
16982 },
16983 },
16984};
16985
16986export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 {
16987 return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } };
16988}
16989export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void {
16990 expect(s.a == 1) catch @panic("test failure");
16991 expect(s.b.c.d == 2) catch @panic("test failure");
16992 expect(s.b.c.e == 3) catch @panic("test failure");
16993}
16994
16995extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32;
16996extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void;
16997extern fn c_test_struct_u32_union_u32_u32u32() void;
16998
16999test "struct{u32,union{u32,struct{u32,u32}}}" {
17000 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17001 if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
17002 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17003 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17004
17005 const s = c_ret_struct_u32_union_u32_u32u32();
17006 try expect(s.a == 1);
17007 try expect(s.b.c.d == 2);
17008 try expect(s.b.c.e == 3);
17009 c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } });
17010 c_test_struct_u32_union_u32_u32u32();
17011}
17012
17013const Struct_i32_i32 = extern struct {
17014 a: i32,
17015 b: i32,
17016};
17017extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32;
17018extern fn c_struct_i32_i32(Struct_i32_i32) void;
17019
17020test "struct i32 i32" {
17021 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17022 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17023 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17024 if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
17025 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
17026
17027 const s: Struct_i32_i32 = .{
17028 .a = 1,
17029 .b = 2,
17030 };
17031 const mut_res = c_mut_struct_i32_i32(s);
17032 try expect(s.a == 1);
17033 try expect(s.b == 2);
17034 try expect(mut_res.a == 101);
17035 try expect(mut_res.b == 252);
17036 c_struct_i32_i32(s);
17037}
17038
17039export fn zig_struct_i32_i32(s: Struct_i32_i32) void {
17040 expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1");
17041 expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2");
17042}
17043
17044const BigStruct = extern struct {
17045 a: u64,
17046 b: u64,
17047 c: u64,
17048 d: u64,
17049 e: u8,
17050};
17051extern fn c_big_struct(BigStruct) void;
17052
17053test "big struct" {
17054 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17055 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17056 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17057 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17058
17059 const s = BigStruct{
17060 .a = 1,
17061 .b = 2,
17062 .c = 3,
17063 .d = 4,
17064 .e = 5,
17065 };
17066 c_big_struct(s);
17067}
17068
17069export fn zig_big_struct(x: BigStruct) void {
17070 expect(x.a == 1) catch @panic("test failure: zig_big_struct 1");
17071 expect(x.b == 2) catch @panic("test failure: zig_big_struct 2");
17072 expect(x.c == 3) catch @panic("test failure: zig_big_struct 3");
17073 expect(x.d == 4) catch @panic("test failure: zig_big_struct 4");
17074 expect(x.e == 5) catch @panic("test failure: zig_big_struct 5");
17075}
17076
17077const BigUnion = extern union {
17078 a: BigStruct,
17079};
17080extern fn c_big_union(BigUnion) void;
17081
17082test "big union" {
17083 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17084 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17085 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17086
17087 const x = BigUnion{
17088 .a = BigStruct{
17089 .a = 1,
17090 .b = 2,
17091 .c = 3,
17092 .d = 4,
17093 .e = 5,
17094 },
17095 };
17096 c_big_union(x);
17097}
17098
17099export fn zig_big_union(x: BigUnion) void {
17100 expect(x.a.a == 1) catch @panic("test failure: zig_big_union a");
17101 expect(x.a.b == 2) catch @panic("test failure: zig_big_union b");
17102 expect(x.a.c == 3) catch @panic("test failure: zig_big_union c");
17103 expect(x.a.d == 4) catch @panic("test failure: zig_big_union d");
17104 expect(x.a.e == 5) catch @panic("test failure: zig_big_union e");
17105}
17106
17107const MedStructMixed = extern struct {
17108 a: u32,
17109 b: f32,
17110 c: f32,
17111 d: u32 = 0,
17112};
17113extern fn c_med_struct_mixed(MedStructMixed) void;
17114extern fn c_ret_med_struct_mixed() MedStructMixed;
17115
17116test "medium struct of ints and floats" {
17117 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17118 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17119 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17120 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17121
17122 const s = MedStructMixed{
17123 .a = 1234,
17124 .b = 100.0,
17125 .c = 1337.0,
17126 };
17127 c_med_struct_mixed(s);
17128 const s2 = c_ret_med_struct_mixed();
17129 try expect(s2.a == 1234);
17130 try expect(s2.b == 100.0);
17131 try expect(s2.c == 1337.0);
17132}
17133
17134export fn zig_med_struct_mixed(x: MedStructMixed) void {
17135 expect(x.a == 1234) catch @panic("test failure");
17136 expect(x.b == 100.0) catch @panic("test failure");
17137 expect(x.c == 1337.0) catch @panic("test failure");
17138}
17139
17140const SmallPackedStruct = packed struct(u8) {
17141 a: u2,
17142 b: u2,
17143 c: u2,
17144 d: u2,
17145};
17146extern fn c_small_packed_struct(SmallPackedStruct) void;
17147extern fn c_ret_small_packed_struct() SmallPackedStruct;
17148
17149export fn zig_small_packed_struct(x: SmallPackedStruct) void {
17150 expect(x.a == 0) catch @panic("test failure");
17151 expect(x.b == 1) catch @panic("test failure");
17152 expect(x.c == 2) catch @panic("test failure");
17153 expect(x.d == 3) catch @panic("test failure");
17154}
17155
17156test "small packed struct" {
17157 const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 };
17158 c_small_packed_struct(s);
17159 const s2 = c_ret_small_packed_struct();
17160 try expect(s2.a == 0);
17161 try expect(s2.b == 1);
17162 try expect(s2.c == 2);
17163 try expect(s2.d == 3);
17164}
17165
17166const BigPackedStruct = packed struct(u128) {
17167 a: u64,
17168 b: u64,
17169};
17170extern fn c_big_packed_struct(BigPackedStruct) void;
17171extern fn c_ret_big_packed_struct() BigPackedStruct;
17172
17173export fn zig_big_packed_struct(x: BigPackedStruct) void {
17174 expect(x.a == 1) catch @panic("test failure");
17175 expect(x.b == 2) catch @panic("test failure");
17176}
17177
17178test "big packed struct" {
17179 if (!have_i128) return error.SkipZigTest;
17180
17181 const s = BigPackedStruct{ .a = 1, .b = 2 };
17182 c_big_packed_struct(s);
17183 const s2 = c_ret_big_packed_struct();
17184 try expect(s2.a == 1);
17185 try expect(s2.b == 2);
17186}
17187
17188const SplitStructInt = extern struct {
17189 a: u64,
17190 b: u8,
17191 c: u32,
17192};
17193extern fn c_split_struct_ints(SplitStructInt) void;
17194
17195test "split struct of ints" {
17196 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17197 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17198 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17199 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17200 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
17201
17202 const s = SplitStructInt{
17203 .a = 1234,
17204 .b = 100,
17205 .c = 1337,
17206 };
17207 c_split_struct_ints(s);
17208}
17209
17210export fn zig_split_struct_ints(x: SplitStructInt) void {
17211 expect(x.a == 1234) catch @panic("test failure");
17212 expect(x.b == 100) catch @panic("test failure");
17213 expect(x.c == 1337) catch @panic("test failure");
17214}
17215
17216const SplitStructMixed = extern struct {
17217 a: u64,
17218 b: u8,
17219 c: f32,
17220};
17221extern fn c_split_struct_mixed(SplitStructMixed) void;
17222extern fn c_ret_split_struct_mixed() SplitStructMixed;
17223
17224test "split struct of ints and floats" {
17225 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17226 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17227 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17228 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17229 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
17230
17231 const s = SplitStructMixed{
17232 .a = 1234,
17233 .b = 100,
17234 .c = 1337.0,
17235 };
17236 c_split_struct_mixed(s);
17237 const s2 = c_ret_split_struct_mixed();
17238 try expect(s2.a == 1234);
17239 try expect(s2.b == 100);
17240 try expect(s2.c == 1337.0);
17241}
17242
17243export fn zig_split_struct_mixed(x: SplitStructMixed) void {
17244 expect(x.a == 1234) catch @panic("test failure");
17245 expect(x.b == 100) catch @panic("test failure");
17246 expect(x.c == 1337.0) catch @panic("test failure");
17247}
17248
17249extern fn c_big_struct_both(BigStruct) BigStruct;
17250
17251test "sret and byval together" {
17252 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17253 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17254 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17255 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17256
17257 const s = BigStruct{
17258 .a = 1,
17259 .b = 2,
17260 .c = 3,
17261 .d = 4,
17262 .e = 5,
17263 };
17264 const y = c_big_struct_both(s);
17265 try expect(y.a == 10);
17266 try expect(y.b == 11);
17267 try expect(y.c == 12);
17268 try expect(y.d == 13);
17269 try expect(y.e == 14);
17270}
17271
17272export fn zig_big_struct_both(x: BigStruct) BigStruct {
17273 expect(x.a == 30) catch @panic("test failure");
17274 expect(x.b == 31) catch @panic("test failure");
17275 expect(x.c == 32) catch @panic("test failure");
17276 expect(x.d == 33) catch @panic("test failure");
17277 expect(x.e == 34) catch @panic("test failure");
17278 const s = BigStruct{
17279 .a = 20,
17280 .b = 21,
17281 .c = 22,
17282 .d = 23,
17283 .e = 24,
17284 };
17285 return s;
17286}
17287
17288export fn zig_ret_bool() bool {
17289 return true;
17290}
17291export fn zig_ret_u8() u8 {
17292 return 0xff;
17293}
17294export fn zig_ret_u16() u16 {
17295 return 0xffff;
17296}
17297export fn zig_ret_u32() u32 {
17298 return 0xffffffff;
17299}
17300export fn zig_ret_u64() u64 {
17301 return 0xffffffffffffffff;
17302}
17303export fn zig_ret_i8() i8 {
17304 return -1;
17305}
17306export fn zig_ret_i16() i16 {
17307 return -1;
17308}
17309export fn zig_ret_i32() i32 {
17310 return -1;
17311}
17312export fn zig_ret_i64() i64 {
17313 return -1;
17314}
17315
17316export fn zig_ret_med_struct_mixed() MedStructMixed {
17317 return .{
17318 .a = 1234,
17319 .b = 100.0,
17320 .c = 1337.0,
17321 };
17322}
17323
17324export fn zig_ret_split_struct_mixed() SplitStructMixed {
17325 return .{
17326 .a = 1234,
17327 .b = 100,
17328 .c = 1337.0,
17329 };
17330}
17331
17332extern fn c_ret_bool() bool;
17333extern fn c_ret_u8() u8;
17334extern fn c_ret_u16() u16;
17335extern fn c_ret_u32() u32;
17336extern fn c_ret_u64() u64;
17337extern fn c_ret_i8() i8;
17338extern fn c_ret_i16() i16;
17339extern fn c_ret_i32() i32;
17340extern fn c_ret_i64() i64;
17341
17342test "integer return types" {
17343 try expect(c_ret_bool() == true);
17344
17345 try expect(c_ret_u8() == 0xff);
17346 try expect(c_ret_u16() == 0xffff);
17347 try expect(c_ret_u32() == 0xffffffff);
17348 try expect(c_ret_u64() == 0xffffffffffffffff);
17349
17350 try expect(c_ret_i8() == -1);
17351 try expect(c_ret_i16() == -1);
17352 try expect(c_ret_i32() == -1);
17353 try expect(c_ret_i64() == -1);
17354}
17355
17356const StructWithArray = extern struct {
17357 a: i32,
17358 padding: [4]u8,
17359 b: i64,
17360};
17361extern fn c_struct_with_array(StructWithArray) void;
17362extern fn c_ret_struct_with_array() StructWithArray;
17363
17364test "Struct with array as padding." {
17365 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17366 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17367 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17368 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17369 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
17370
17371 c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 });
17372
17373 const x = c_ret_struct_with_array();
17374 try expect(x.a == 4);
17375 try expect(x.b == 155);
17376}
17377
17378const FloatArrayStruct = extern struct {
17379 origin: extern struct {
17380 x: f64,
17381 y: f64,
17382 },
17383 size: extern struct {
17384 width: f64,
17385 height: f64,
17386 },
17387};
17388
17389extern fn c_float_array_struct(FloatArrayStruct) void;
17390extern fn c_ret_float_array_struct() FloatArrayStruct;
17391
17392test "Float array like struct" {
17393 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17394 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17395 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17396 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
17397
17398 c_float_array_struct(.{
17399 .origin = .{
17400 .x = 5,
17401 .y = 6,
17402 },
17403 .size = .{
17404 .width = 7,
17405 .height = 8,
17406 },
17407 });
17408
17409 const x = c_ret_float_array_struct();
17410 try expect(x.origin.x == 1);
17411 try expect(x.origin.y == 2);
17412 try expect(x.size.width == 3);
17413 try expect(x.size.height == 4);
17414}
17415
17416//=== Helpers for struct test ===//
17417pub inline fn expectOk(c_err: c_int) !void {
17418 if (c_err != 0) {
17419 std.debug.print("ABI mismatch on field v{d}.\n", .{c_err});
17420 return error.TestExpectedEqual;
17421 }
17422}
17423
17424/// Tests for Double + Char struct
17425const DC = extern struct { v1: f64, v2: u8 };
17426test "DC: Zig passes to C" {
17427 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17428 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17429 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17430 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17431 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
17432
17433 try expectOk(c_assert_DC(.{ .v1 = -0.25, .v2 = 15 }));
17434}
17435test "DC: Zig returns to C" {
17436 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17437 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17438 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17439 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
17440
17441 try expectOk(c_assert_ret_DC());
17442}
17443test "DC: C passes to Zig" {
17444 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17445 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17446 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17447 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17448 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
17449
17450 try expectOk(c_send_DC());
17451}
17452test "DC: C returns to Zig" {
17453 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17454 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17455 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17456 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
17457
17458 try expectEqual(DC{ .v1 = -0.25, .v2 = 15 }, c_ret_DC());
17459}
17460
17461pub extern fn c_assert_DC(lv: DC) c_int;
17462pub extern fn c_assert_ret_DC() c_int;
17463pub extern fn c_send_DC() c_int;
17464pub extern fn c_ret_DC() DC;
17465pub export fn zig_assert_DC(lv: DC) c_int {
17466 var err: c_int = 0;
17467 if (lv.v1 != -0.25) err = 1;
17468 if (lv.v2 != 15) err = 2;
17469 if (err != 0) std.debug.print("Received {}", .{lv});
17470 return err;
17471}
17472pub export fn zig_ret_DC() DC {
17473 return .{ .v1 = -0.25, .v2 = 15 };
17474}
17475
17476/// Tests for Char + Float + FloatRect struct
17477const CFF = extern struct { v1: u8, v2: f32, v3: f32 };
17478
17479test "CFF: Zig passes to C" {
17480 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
17481 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17482 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17483 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17484 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17485
17486 try expectOk(c_assert_CFF(.{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }));
17487}
17488test "CFF: Zig returns to C" {
17489 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17490 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17491 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17492
17493 try expectOk(c_assert_ret_CFF());
17494}
17495test "CFF: C passes to Zig" {
17496 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17497 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17498 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17499 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17500 if (builtin.cpu.arch.isRISCV() and builtin.mode != .debug) return error.SkipZigTest;
17501 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
17502
17503 try expectOk(c_send_CFF());
17504}
17505test "CFF: C returns to Zig" {
17506 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17507 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17508 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17509 if (builtin.cpu.arch.isRISCV() and builtin.mode != .debug) return error.SkipZigTest;
17510
17511 try expectEqual(CFF{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }, c_ret_CFF());
17512}
17513pub extern fn c_assert_CFF(lv: CFF) c_int;
17514pub extern fn c_assert_ret_CFF() c_int;
17515pub extern fn c_send_CFF() c_int;
17516pub extern fn c_ret_CFF() CFF;
17517pub export fn zig_assert_CFF(lv: CFF) c_int {
17518 var err: c_int = 0;
17519 if (lv.v1 != 39) err = 1;
17520 if (lv.v2 != 0.875) err = 2;
17521 if (lv.v3 != 1.0) err = 3;
17522 if (err != 0) std.debug.print("Received {}", .{lv});
17523 return err;
17524}
17525pub export fn zig_ret_CFF() CFF {
17526 return .{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 };
17527}
17528
17529/// Tests for Pointer + Double struct
17530const PD = extern struct { v1: ?*anyopaque, v2: f64 };
17531
17532test "PD: Zig passes to C" {
17533 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17534 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17535 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17536 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17537 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
17538
17539 try expectOk(c_assert_PD(.{ .v1 = null, .v2 = 0.5 }));
17540}
17541test "PD: Zig returns to C" {
17542 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17543 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17544 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17545
17546 try expectOk(c_assert_ret_PD());
17547}
17548test "PD: C passes to Zig" {
17549 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17550 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17551 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17552 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17553 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
17554
17555 try expectOk(c_send_PD());
17556}
17557test "PD: C returns to Zig" {
17558 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17559 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17560 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17561
17562 try expectEqual(PD{ .v1 = null, .v2 = 0.5 }, c_ret_PD());
17563}
17564pub extern fn c_assert_PD(lv: PD) c_int;
17565pub extern fn c_assert_ret_PD() c_int;
17566pub extern fn c_send_PD() c_int;
17567pub extern fn c_ret_PD() PD;
17568pub export fn zig_c_assert_PD(lv: PD) c_int {
17569 var err: c_int = 0;
17570 if (lv.v1 != null) err = 1;
17571 if (lv.v2 != 0.5) err = 2;
17572 if (err != 0) std.debug.print("Received {}", .{lv});
17573 return err;
17574}
17575pub export fn zig_ret_PD() PD {
17576 return .{ .v1 = null, .v2 = 0.5 };
17577}
17578pub export fn zig_assert_PD(lv: PD) c_int {
17579 var err: c_int = 0;
17580 if (lv.v1 != null) err = 1;
17581 if (lv.v2 != 0.5) err = 2;
17582 if (err != 0) std.debug.print("Received {}", .{lv});
17583 return err;
17584}
17585
17586const ByRef = extern struct {
17587 val: c_int,
17588 arr: [15]c_int,
17589};
17590extern fn c_modify_by_ref_param(ByRef) ByRef;
17591
17592test "C function modifies by ref param" {
17593 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17594 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17595
17596 const res = c_modify_by_ref_param(.{ .val = 1, .arr = undefined });
17597 try expect(res.val == 42);
17598}
17599
17600const ByVal = extern struct {
17601 origin: extern struct {
17602 x: c_ulong,
17603 y: c_ulong,
17604 z: c_ulong,
17605 },
17606 size: extern struct {
17607 width: c_ulong,
17608 height: c_ulong,
17609 depth: c_ulong,
17610 },
17611};
17612
17613extern fn c_func_ptr_byval(*anyopaque, *anyopaque, ByVal, c_ulong, *anyopaque, c_ulong) void;
17614test "C function that takes byval struct called via function pointer" {
17615 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17616 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17617 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17618 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17619
17620 var fn_ptr = &c_func_ptr_byval;
17621 _ = &fn_ptr;
17622 fn_ptr(
17623 @as(*anyopaque, @ptrFromInt(1)),
17624 @as(*anyopaque, @ptrFromInt(2)),
17625 ByVal{
17626 .origin = .{ .x = 9, .y = 10, .z = 11 },
17627 .size = .{ .width = 12, .height = 13, .depth = 14 },
17628 },
17629 @as(c_ulong, 3),
17630 @as(*anyopaque, @ptrFromInt(4)),
17631 @as(c_ulong, 5),
17632 );
17633}
17634
17635extern fn c_f16(f16) f16;
17636test "f16 bare" {
17637 if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
17638 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17639 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17640 if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
17641 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
17642 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
17643 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
17644 if (builtin.cpu.arch.isWasm()) return error.SkipZigTest;
17645 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
17646 if (builtin.cpu.arch == .x86_64) return error.SkipZigTest;
17647
17648 const a = c_f16(12);
17649 try expect(a == 34);
17650}
17651
17652const f16_struct = extern struct {
17653 a: f16,
17654};
17655extern fn c_f16_struct(f16_struct) f16_struct;
17656test "f16 struct" {
17657 if (builtin.cpu.arch.isArm() and builtin.mode != .debug) return error.SkipZigTest;
17658 if (builtin.target.cpu.arch.isMIPS64()) return error.SkipZigTest;
17659 if (builtin.target.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17660 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
17661 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
17662
17663 const a = c_f16_struct(.{ .a = 12 });
17664 try expect(a.a == 34);
17665}
17666
17667extern fn c_f80(f80) f80;
17668test "f80 bare" {
17669 if (!have_f80) return error.SkipZigTest;
17670
17671 const a = c_f80(12.34);
17672 try expect(@as(f64, @floatCast(a)) == 56.78);
17673}
17674
17675const f80_struct = extern struct {
17676 a: f80,
17677};
17678extern fn c_f80_struct(f80_struct) f80_struct;
17679test "f80 struct" {
17680 if (!have_f80) return error.SkipZigTest;
17681
17682 const a = c_f80_struct(.{ .a = 12.34 });
17683 try expect(@as(f64, @floatCast(a.a)) == 56.78);
17684}
17685
17686const f80_extra_struct = extern struct {
17687 a: f80,
17688 b: c_int,
17689};
17690extern fn c_f80_extra_struct(f80_extra_struct) f80_extra_struct;
17691test "f80 extra struct" {
17692 if (!have_f80) return error.SkipZigTest;
17693
17694 const a = c_f80_extra_struct(.{ .a = 12.34, .b = 42 });
17695 try expect(@as(f64, @floatCast(a.a)) == 56.78);
17696 try expect(a.b == 24);
17697}
17698
17699export fn zig_f128(x: f128) f128 {
17700 expect(x == 12) catch @panic("test failure");
17701 return 34;
17702}
17703extern fn c_f128(f128) f128;
17704test "f128 bare" {
17705 if (!have_f128) return error.SkipZigTest;
17706
17707 const a = c_f128(12.34);
17708 try expect(@as(f64, @floatCast(a)) == 56.78);
17709}
17710
17711const f128_struct = extern struct {
17712 a: f128,
17713};
17714export fn zig_f128_struct(a: f128_struct) f128_struct {
17715 expect(a.a == 12345) catch @panic("test failure");
17716 return .{ .a = 98765 };
17717}
17718extern fn c_f128_struct(f128_struct) f128_struct;
17719test "f128 struct" {
17720 if (!have_f128) return error.SkipZigTest;
17721
17722 const a = c_f128_struct(.{ .a = 12.34 });
17723 try expect(@as(f64, @floatCast(a.a)) == 56.78);
17724
17725 const b = c_f128_f128_struct(.{ .a = 12.34, .b = 87.65 });
17726 try expect(@as(f64, @floatCast(b.a)) == 56.78);
17727 try expect(@as(f64, @floatCast(b.b)) == 43.21);
17728}
17729
17730const f128_f128_struct = extern struct {
17731 a: f128,
17732 b: f128,
17733};
17734export fn zig_f128_f128_struct(a: f128_f128_struct) f128_f128_struct {
17735 expect(a.a == 13) catch @panic("test failure");
17736 expect(a.b == 57) catch @panic("test failure");
17737 return .{ .a = 24, .b = 68 };
17738}
17739extern fn c_f128_f128_struct(f128_f128_struct) f128_f128_struct;
17740test "f128 f128 struct" {
17741 if (!have_f128) return error.SkipZigTest;
17742
17743 const a = c_f128_struct(.{ .a = 12.34 });
17744 try expect(@as(f64, @floatCast(a.a)) == 56.78);
17745
17746 const b = c_f128_f128_struct(.{ .a = 12.34, .b = 87.65 });
17747 try expect(@as(f64, @floatCast(b.a)) == 56.78);
17748 try expect(@as(f64, @floatCast(b.b)) == 43.21);
17749}
17750
17751// The stdcall attribute on C functions is ignored when compiled on non-x86
17752const stdcall_callconv: std.builtin.CallingConvention = if (builtin.cpu.arch == .x86) .{ .x86_stdcall = .{} } else .c;
17753
17754extern fn stdcall_scalars(i8, i16, i32, f32, f64) callconv(stdcall_callconv) void;
17755test "Stdcall ABI scalars" {
17756 stdcall_scalars(1, 2, 3, 4.0, 5.0);
17757}
17758
17759const Coord2 = extern struct {
17760 x: i16,
17761 y: i16,
17762};
17763
17764extern fn stdcall_coord2(Coord2, Coord2, Coord2) callconv(stdcall_callconv) Coord2;
17765test "Stdcall ABI structs" {
17766 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17767 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17768 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17769 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
17770 if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
17771
17772 const res = stdcall_coord2(
17773 .{ .x = 0x1111, .y = 0x2222 },
17774 .{ .x = 0x3333, .y = 0x4444 },
17775 .{ .x = 0x5555, .y = 0x6666 },
17776 );
17777 try expect(res.x == 123);
17778 try expect(res.y == 456);
17779}
17780
17781extern fn stdcall_big_union(BigUnion) callconv(stdcall_callconv) void;
17782test "Stdcall ABI big union" {
17783 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17784 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17785 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
17786
17787 const x = BigUnion{
17788 .a = BigStruct{
17789 .a = 1,
17790 .b = 2,
17791 .c = 3,
17792 .d = 4,
17793 .e = 5,
17794 },
17795 };
17796 stdcall_big_union(x);
17797}
17798
17799extern fn c_explict_win64(ByRef) callconv(.{ .x86_64_win = .{} }) ByRef;
17800test "explicit Win64 calling convention" {
17801 if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
17802
17803 const res = c_explict_win64(.{ .val = 1, .arr = undefined });
17804 try expect(res.val == 42);
17805}
17806
17807extern fn c_explict_sys_v(ByRef) callconv(.{ .x86_64_sysv = .{} }) ByRef;
17808test "explicit SysV calling convention" {
17809 if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
17810
17811 const res = c_explict_sys_v(.{ .val = 1, .arr = undefined });
17812 try expect(res.val == 42);
17813}
17814
17815const byval_tail_callsite_attr = struct {
17816 const struct_Point = extern struct {
17817 x: f64,
17818 y: f64,
17819 };
17820 const struct_Size = extern struct {
17821 width: f64,
17822 height: f64,
17823 };
17824 const struct_Rect = extern struct {
17825 origin: struct_Point,
17826 size: struct_Size,
17827 };
17828
17829 const Point = extern struct {
17830 x: f64,
17831 y: f64,
17832 };
17833
17834 const Size = extern struct {
17835 width: f64,
17836 height: f64,
17837 };
17838
17839 const MyRect = extern struct {
17840 origin: Point,
17841 size: Size,
17842
17843 fn run(self: MyRect) f64 {
17844 return c_byval_tail_callsite_attr(cast(self));
17845 }
17846
17847 fn cast(self: MyRect) struct_Rect {
17848 const ptr: *const struct_Rect = @ptrCast(&self);
17849 return ptr.*;
17850 }
17851
17852 extern fn c_byval_tail_callsite_attr(struct_Rect) f64;
17853 };
17854};
17855
17856test "byval tail callsite attribute" {
17857 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
17858 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
17859 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
17860 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
17861
17862 // Originally reported at https://github.com/ziglang/zig/issues/16290
17863 // the bug was that the extern function had the byval attribute, but
17864 // zig did not put the byval attribute at the callsite. Some LLVM optimization
17865 // passes would then pass undefined for that parameter.
17866 var v: byval_tail_callsite_attr.MyRect = .{
17867 .origin = .{ .x = 1, .y = 2 },
17868 .size = .{ .width = 3, .height = 4 },
17869 };
17870 try expect(v.run() == 3.0);
17871}
17872
17873test "x86 fastcall calling convention" {
17874 if (builtin.cpu.arch != .x86 or builtin.os.tag != .windows or builtin.abi != .msvc) return error.SkipZigTest;
17875
17876 const static = struct {
17877 const fastcall: std.builtin.CallingConvention = .{ .x86_fastcall = .{} };
17878
17879 extern fn c_fastcall_check(a: c_int, b: f32, c: *anyopaque, d: f64, e: c_int) callconv(fastcall) void;
17880 export fn zig_fastcall_check(a: c_int, b: f32, c: *anyopaque, d: f64, e: c_int) callconv(fastcall) void {
17881 if (a != 1) @panic("test failure");
17882 if (b != 2.0) @panic("test failure");
17883 if (@intFromPtr(c) != 3) @panic("test failure");
17884 if (d != 4.0) @panic("test failure");
17885 if (e != 5) @panic("test failure");
17886 }
17887
17888 const SRet = extern struct {
17889 a: i32,
17890 b: i32,
17891 c: i32,
17892 };
17893 extern fn c_fastcall_sret() callconv(fastcall) SRet;
17894 export fn zig_fastcall_sret() callconv(fastcall) SRet {
17895 return .{
17896 .a = 1,
17897 .b = 2,
17898 .c = 3,
17899 };
17900 }
17901
17902 const NoSRet = extern struct {
17903 a: i8,
17904 b: i16,
17905 };
17906 extern fn c_fastcall_no_sret() callconv(fastcall) NoSRet;
17907 export fn zig_fastcall_no_sret() callconv(fastcall) NoSRet {
17908 return .{
17909 .a = 1,
17910 .b = 2,
17911 };
17912 }
17913
17914 const NoSRetF32F32 = extern struct {
17915 a: f32,
17916 b: f32,
17917 };
17918 extern fn c_fastcall_no_sret_f32_f32() callconv(fastcall) NoSRetF32F32;
17919 export fn zig_fastcall_no_sret_f32_f32() callconv(fastcall) NoSRetF32F32 {
17920 return .{
17921 .a = 1,
17922 .b = 2,
17923 };
17924 }
17925
17926 const NoSRetF64 = extern struct {
17927 a: f64,
17928 };
17929 extern fn c_fastcall_no_sret_f64() callconv(fastcall) NoSRetF64;
17930 export fn zig_fastcall_no_sret_f64() callconv(fastcall) NoSRetF64 {
17931 return .{
17932 .a = 1,
17933 };
17934 }
17935
17936 extern fn c_fastcall_ret_f32() callconv(fastcall) f32;
17937 export fn zig_fastcall_ret_f32() callconv(fastcall) f32 {
17938 return 1;
17939 }
17940
17941 extern fn c_fastcall_ret_f64() callconv(fastcall) f64;
17942 export fn zig_fastcall_ret_f64() callconv(fastcall) f64 {
17943 return 1;
17944 }
17945
17946 extern fn run_c_fastcall_tests() void;
17947 };
17948
17949 static.c_fastcall_check(1, 2.0, @ptrFromInt(3), 4.0, 5);
17950
17951 {
17952 const s = static.c_fastcall_sret();
17953 try expect(s.a == 1);
17954 try expect(s.b == 2);
17955 try expect(s.c == 3);
17956 }
17957 {
17958 const s = static.c_fastcall_no_sret();
17959 try expect(s.a == 1);
17960 try expect(s.b == 2);
17961 }
17962 {
17963 const s = static.c_fastcall_no_sret_f32_f32();
17964 try expect(s.a == 1);
17965 try expect(s.b == 2);
17966 }
17967 {
17968 const s = static.c_fastcall_no_sret_f64();
17969 try expect(s.a == 1);
17970 }
17971 {
17972 const s = static.c_fastcall_ret_f32();
17973 try expect(s == 1);
17974 }
17975 {
17976 const s = static.c_fastcall_ret_f64();
17977 try expect(s == 1);
17978 }
17979
17980 static.run_c_fastcall_tests();
17981}
17982
17983test "x86 vectorcall calling convention" {
17984 if (builtin.cpu.arch != .x86 or builtin.os.tag != .windows or builtin.abi != .msvc) return error.SkipZigTest;
17985
17986 const static = struct {
17987 extern fn c_vectorcall_check(a: c_int, b: f32, c: f64, d: *anyopaque, e: f32, f: f64, g: f64, h: f32, i: f32, j: c_int) callconv(.{ .x86_vectorcall = .{} }) void;
17988 export fn zig_vectorcall_check(a: c_int, b: f32, c: f64, d: *anyopaque, e: f32, f: f64, g: f64, h: f32, i: f32, j: c_int) callconv(.{ .x86_vectorcall = .{} }) void {
17989 if (a != 1) @panic("test failure");
17990 if (b != 2.0) @panic("test failure");
17991 if (c != 3.0) @panic("test failure");
17992 if (@intFromPtr(d) != 4) @panic("test failure");
17993 if (e != 5.0) @panic("test failure");
17994 if (f != 6.0) @panic("test failure");
17995 if (g != 7.0) @panic("test failure");
17996 if (h != 8.0) @panic("test failure");
17997 if (i != 9.0) @panic("test failure");
17998 if (j != 10) @panic("test failure");
17999 }
18000 };
18001 static.c_vectorcall_check(1, 2.0, 3.0, @ptrFromInt(4), 5.0, 6.0, 7.0, 8.0, 9.0, 10);
18002}
18003
18004extern fn c_x86_64_sysv_uint_int_uint_int(a: u8, b: i8, c: u16, d: i16) void;
18005
18006test "x86_64 sysv args" {
18007 if (std.lang.CallingConvention.c != .x86_64_sysv) return error.SkipZigTest;
18008
18009 c_x86_64_sysv_uint_int_uint_int(1, -2, 3, -4);
18010}
18011
18012extern fn c_win64_varargs_u64_f64_u64_f64(...) void;
18013extern fn c_win64_varargs_f64_u64_f64_u64(...) void;
18014
18015test "win64 varargs" {
18016 if (std.lang.CallingConvention.c != .x86_64_win) return error.SkipZigTest;
18017
18018 const Opv = extern struct {};
18019 c_win64_varargs_u64_f64_u64_f64(
18020 @as(Opv, .{}),
18021 @as(f32, 1),
18022 @as(Opv, .{}),
18023 @as(f32, 2.0),
18024 @as(Opv, .{}),
18025 @as(f64, 3),
18026 @as(Opv, .{}),
18027 @as(f64, 4.0),
18028 @as(Opv, .{}),
18029 );
18030 c_win64_varargs_f64_u64_f64_u64(
18031 @as(Opv, .{}),
18032 @as(f32, 5),
18033 @as(Opv, .{}),
18034 @as(f32, 6.0),
18035 @as(Opv, .{}),
18036 @as(f64, 7),
18037 @as(Opv, .{}),
18038 @as(f64, 8.0),
18039 @as(Opv, .{}),
18040 );
18041}
18042
18043const preserve_none_cc: ?std.lang.CallingConvention = if (builtin.zig_backend != .stage2_llvm)
18044 null
18045else switch (builtin.cpu.arch) {
18046 .x86_64 => .{ .x86_64_preserve_none = .{} },
18047 .aarch64, .aarch64_be => .{ .aarch64_preserve_none = .{} },
18048 else => null,
18049};
18050
18051export fn zig_preserve_none(x: i32) callconv(preserve_none_cc orelse .c) i32 {
18052 return x + 1;
18053}
18054
18055test "preserve_none calling convention" {
18056 if (preserve_none_cc == null) return error.SkipZigTest;
18057 const static = struct {
18058 extern fn c_preserve_none(x: i32) callconv(preserve_none_cc.?) i32;
18059 extern fn c_preserve_none_check() void;
18060 };
18061 try expect(static.c_preserve_none(41) == 42);
18062 static.c_preserve_none_check();
18063}