master
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; // https://github.com/llvm/llvm-project/issues/168460
17
18const have_f128 = builtin.cpu.arch.isWasm() or (builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin());
19const have_f80 = builtin.cpu.arch.isX86();
20
21extern fn run_c_tests() void;
22
23export fn zig_panic() noreturn {
24 @panic("zig_panic called from C");
25}
26
27test "C importing Zig ABI Tests" {
28 run_c_tests();
29}
30
31extern fn c_u8(u8) void;
32extern fn c_u16(u16) void;
33extern fn c_u32(u32) void;
34extern fn c_u64(u64) void;
35extern fn c_struct_u128(U128) void;
36extern fn c_i8(i8) void;
37extern fn c_i16(i16) void;
38extern fn c_i32(i32) void;
39extern fn c_i64(i64) void;
40extern fn c_struct_i128(I128) void;
41
42// On windows x64, the first 4 are passed via registers, others on the stack.
43extern fn c_five_integers(i32, i32, i32, i32, i32) void;
44
45export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void {
46 expect(a == 12) catch @panic("test failure: zig_five_integers 12");
47 expect(b == 34) catch @panic("test failure: zig_five_integers 34");
48 expect(c == 56) catch @panic("test failure: zig_five_integers 56");
49 expect(d == 78) catch @panic("test failure: zig_five_integers 78");
50 expect(e == 90) catch @panic("test failure: zig_five_integers 90");
51}
52
53test "C ABI integers" {
54 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
55
56 c_u8(0xff);
57 c_u16(0xfffe);
58 c_u32(0xfffffffd);
59 c_u64(0xfffffffffffffffc);
60 if (have_i128) c_struct_u128(.{ .value = 0xfffffffffffffffc });
61
62 c_i8(-1);
63 c_i16(-2);
64 c_i32(-3);
65 c_i64(-4);
66 if (have_i128) c_struct_i128(.{ .value = -6 });
67 c_five_integers(12, 34, 56, 78, 90);
68}
69
70export fn zig_u8(x: u8) void {
71 expect(x == 0xff) catch @panic("test failure: zig_u8");
72}
73export fn zig_u16(x: u16) void {
74 expect(x == 0xfffe) catch @panic("test failure: zig_u16");
75}
76export fn zig_u32(x: u32) void {
77 expect(x == 0xfffffffd) catch @panic("test failure: zig_u32");
78}
79export fn zig_u64(x: u64) void {
80 expect(x == 0xfffffffffffffffc) catch @panic("test failure: zig_u64");
81}
82export fn zig_i8(x: i8) void {
83 expect(x == -1) catch @panic("test failure: zig_i8");
84}
85export fn zig_i16(x: i16) void {
86 expect(x == -2) catch @panic("test failure: zig_i16");
87}
88export fn zig_i32(x: i32) void {
89 expect(x == -3) catch @panic("test failure: zig_i32");
90}
91export fn zig_i64(x: i64) void {
92 expect(x == -4) catch @panic("test failure: zig_i64");
93}
94
95const I128 = extern struct {
96 value: i128,
97};
98const U128 = extern struct {
99 value: u128,
100};
101export fn zig_struct_i128(a: I128) void {
102 expect(a.value == -6) catch @panic("test failure: zig_struct_i128");
103}
104export fn zig_struct_u128(a: U128) void {
105 expect(a.value == 0xfffffffffffffffc) catch @panic("test failure: zig_struct_u128");
106}
107
108extern fn c_f32(f32) void;
109extern fn c_f64(f64) void;
110extern fn c_long_double(c_longdouble) void;
111
112// On windows x64, the first 4 are passed via registers, others on the stack.
113extern fn c_five_floats(f32, f32, f32, f32, f32) void;
114
115export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {
116 expect(a == 1.0) catch @panic("test failure: zig_five_floats 1.0");
117 expect(b == 2.0) catch @panic("test failure: zig_five_floats 2.0");
118 expect(c == 3.0) catch @panic("test failure: zig_five_floats 3.0");
119 expect(d == 4.0) catch @panic("test failure: zig_five_floats 4.0");
120 expect(e == 5.0) catch @panic("test failure: zig_five_floats 5.0");
121}
122
123test "C ABI floats" {
124 c_f32(12.34);
125 c_f64(56.78);
126 c_five_floats(1.0, 2.0, 3.0, 4.0, 5.0);
127}
128
129test "C ABI long double" {
130 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
131
132 c_long_double(12.34);
133}
134
135export fn zig_f32(x: f32) void {
136 expect(x == 12.34) catch @panic("test failure: zig_f32");
137}
138export fn zig_f64(x: f64) void {
139 expect(x == 56.78) catch @panic("test failure: zig_f64");
140}
141export fn zig_longdouble(x: c_longdouble) void {
142 if (!builtin.target.cpu.arch.isWasm()) return; // waiting for #1481
143 expect(x == 12.34) catch @panic("test failure: zig_longdouble");
144}
145
146extern fn c_ptr(*anyopaque) void;
147
148test "C ABI pointer" {
149 c_ptr(@as(*anyopaque, @ptrFromInt(0xdeadbeef)));
150}
151
152export fn zig_ptr(x: *anyopaque) void {
153 expect(@intFromPtr(x) == 0xdeadbeef) catch @panic("test failure: zig_ptr");
154}
155
156extern fn c_bool(bool) void;
157
158test "C ABI bool" {
159 c_bool(true);
160}
161
162export fn zig_bool(x: bool) void {
163 expect(x) catch @panic("test failure: zig_bool");
164}
165
166// TODO: Replace these with the correct types once we resolve
167// https://github.com/ziglang/zig/issues/8465
168//
169// For now, we have no way of referring to the _Complex C types from Zig,
170// so our ABI is unavoidably broken on some platforms (such as x86)
171const ComplexFloat = extern struct {
172 real: f32,
173 imag: f32,
174};
175const ComplexDouble = extern struct {
176 real: f64,
177 imag: f64,
178};
179
180// Note: These two functions match the signature of __mulsc3 and __muldc3 in compiler-rt (and libgcc)
181extern fn c_cmultf_comp(a_r: f32, a_i: f32, b_r: f32, b_i: f32) ComplexFloat;
182extern fn c_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble;
183
184extern fn c_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat;
185extern fn c_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble;
186
187const complex_abi_compatible = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isMIPS() and
188 !builtin.cpu.arch.isArm() and !builtin.cpu.arch.isPowerPC32() and !builtin.cpu.arch.isRISCV() and
189 builtin.cpu.arch != .hexagon and
190 builtin.cpu.arch != .s390x;
191
192test "C ABI complex float" {
193 if (!complex_abi_compatible) return error.SkipZigTest;
194
195 const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
196 const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
197
198 const z = c_cmultf(a, b);
199 try expect(z.real == 1.5);
200 try expect(z.imag == 13.5);
201}
202
203test "C ABI complex float by component" {
204 if (!complex_abi_compatible) return error.SkipZigTest;
205
206 const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
207 const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
208
209 const z2 = c_cmultf_comp(a.real, a.imag, b.real, b.imag);
210 try expect(z2.real == 1.5);
211 try expect(z2.imag == 13.5);
212}
213
214test "C ABI complex double" {
215 if (!complex_abi_compatible) return error.SkipZigTest;
216
217 const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
218 const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
219
220 const z = c_cmultd(a, b);
221 try expect(z.real == 1.5);
222 try expect(z.imag == 13.5);
223}
224
225test "C ABI complex double by component" {
226 if (!complex_abi_compatible) return error.SkipZigTest;
227
228 const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
229 const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
230
231 const z = c_cmultd_comp(a.real, a.imag, b.real, b.imag);
232 try expect(z.real == 1.5);
233 try expect(z.imag == 13.5);
234}
235
236export fn zig_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat {
237 expect(a.real == 1.25) catch @panic("test failure: zig_cmultf 1");
238 expect(a.imag == 2.6) catch @panic("test failure: zig_cmultf 2");
239 expect(b.real == 11.3) catch @panic("test failure: zig_cmultf 3");
240 expect(b.imag == -1.5) catch @panic("test failure: zig_cmultf 4");
241
242 return .{ .real = 1.5, .imag = 13.5 };
243}
244
245export fn zig_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble {
246 expect(a.real == 1.25) catch @panic("test failure: zig_cmultd 1");
247 expect(a.imag == 2.6) catch @panic("test failure: zig_cmultd 2");
248 expect(b.real == 11.3) catch @panic("test failure: zig_cmultd 3");
249 expect(b.imag == -1.5) catch @panic("test failure: zig_cmultd 4");
250
251 return .{ .real = 1.5, .imag = 13.5 };
252}
253
254export fn zig_cmultf_comp(a_r: f32, a_i: f32, b_r: f32, b_i: f32) ComplexFloat {
255 expect(a_r == 1.25) catch @panic("test failure: zig_cmultf_comp 1");
256 expect(a_i == 2.6) catch @panic("test failure: zig_cmultf_comp 2");
257 expect(b_r == 11.3) catch @panic("test failure: zig_cmultf_comp 3");
258 expect(b_i == -1.5) catch @panic("test failure: zig_cmultf_comp 4");
259
260 return .{ .real = 1.5, .imag = 13.5 };
261}
262
263export fn zig_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble {
264 expect(a_r == 1.25) catch @panic("test failure: zig_cmultd_comp 1");
265 expect(a_i == 2.6) catch @panic("test failure: zig_cmultd_comp 2");
266 expect(b_r == 11.3) catch @panic("test failure: zig_cmultd_comp 3");
267 expect(b_i == -1.5) catch @panic("test failure: zig_cmultd_comp 4");
268
269 return .{ .real = 1.5, .imag = 13.5 };
270}
271
272const Struct_u64_u64 = extern struct {
273 a: u64,
274 b: u64,
275};
276
277export fn zig_ret_struct_u64_u64() Struct_u64_u64 {
278 return .{ .a = 1, .b = 2 };
279}
280
281export fn zig_struct_u64_u64_0(s: Struct_u64_u64, i: usize) void {
282 expect(s.a == 3) catch @panic("test failure");
283 expect(s.b == 4) catch @panic("test failure");
284 expect(i == 1) catch @panic("test failure");
285}
286export fn zig_struct_u64_u64_1(_: usize, s: Struct_u64_u64, i: usize) void {
287 expect(s.a == 5) catch @panic("test failure");
288 expect(s.b == 6) catch @panic("test failure");
289 expect(i == 2) catch @panic("test failure");
290}
291export fn zig_struct_u64_u64_2(_: usize, _: usize, s: Struct_u64_u64, i: usize) void {
292 expect(s.a == 7) catch @panic("test failure");
293 expect(s.b == 8) catch @panic("test failure");
294 expect(i == 3) catch @panic("test failure");
295}
296export fn zig_struct_u64_u64_3(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
297 expect(s.a == 9) catch @panic("test failure");
298 expect(s.b == 10) catch @panic("test failure");
299 expect(i == 4) catch @panic("test failure");
300}
301export fn zig_struct_u64_u64_4(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
302 expect(s.a == 11) catch @panic("test failure");
303 expect(s.b == 12) catch @panic("test failure");
304 expect(i == 5) catch @panic("test failure");
305}
306export fn zig_struct_u64_u64_5(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
307 expect(s.a == 13) catch @panic("test failure");
308 expect(s.b == 14) catch @panic("test failure");
309 expect(i == 6) catch @panic("test failure");
310}
311export fn zig_struct_u64_u64_6(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
312 expect(s.a == 15) catch @panic("test failure");
313 expect(s.b == 16) catch @panic("test failure");
314 expect(i == 7) catch @panic("test failure");
315}
316export fn zig_struct_u64_u64_7(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
317 expect(s.a == 17) catch @panic("test failure");
318 expect(s.b == 18) catch @panic("test failure");
319 expect(i == 8) catch @panic("test failure");
320}
321export fn zig_struct_u64_u64_8(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
322 expect(s.a == 19) catch @panic("test failure");
323 expect(s.b == 20) catch @panic("test failure");
324 expect(i == 9) catch @panic("test failure");
325}
326
327extern fn c_ret_struct_u64_u64() Struct_u64_u64;
328
329extern fn c_struct_u64_u64_0(Struct_u64_u64, usize) void;
330extern fn c_struct_u64_u64_1(usize, Struct_u64_u64, usize) void;
331extern fn c_struct_u64_u64_2(usize, usize, Struct_u64_u64, usize) void;
332extern fn c_struct_u64_u64_3(usize, usize, usize, Struct_u64_u64, usize) void;
333extern fn c_struct_u64_u64_4(usize, usize, usize, usize, Struct_u64_u64, usize) void;
334extern fn c_struct_u64_u64_5(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
335extern fn c_struct_u64_u64_6(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
336extern fn c_struct_u64_u64_7(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
337extern fn c_struct_u64_u64_8(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
338
339test "C ABI struct u64 u64" {
340 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
341 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
342 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
343 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
344
345 const s = c_ret_struct_u64_u64();
346 try expect(s.a == 21);
347 try expect(s.b == 22);
348 c_struct_u64_u64_0(.{ .a = 23, .b = 24 }, 1);
349 c_struct_u64_u64_1(0, .{ .a = 25, .b = 26 }, 2);
350 c_struct_u64_u64_2(0, 1, .{ .a = 27, .b = 28 }, 3);
351 c_struct_u64_u64_3(0, 1, 2, .{ .a = 29, .b = 30 }, 4);
352 c_struct_u64_u64_4(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5);
353 c_struct_u64_u64_5(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6);
354 c_struct_u64_u64_6(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7);
355 c_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8);
356 c_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9);
357}
358
359const Struct_f32 = extern struct {
360 a: f32,
361};
362
363export fn zig_ret_struct_f32() Struct_f32 {
364 return .{ .a = 2.5 };
365}
366
367export fn zig_struct_f32(s: Struct_f32) void {
368 expect(s.a == 2.5) catch @panic("test failure");
369}
370
371extern fn c_ret_struct_f32() Struct_f32;
372
373extern fn c_struct_f32(Struct_f32) void;
374
375test "C ABI struct f32" {
376 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
377 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
378 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
379
380 const s = c_ret_struct_f32();
381 try expect(s.a == 2.5);
382 c_struct_f32(.{ .a = 2.5 });
383}
384
385const Struct_f64 = extern struct {
386 a: f64,
387};
388
389export fn zig_ret_struct_f64() Struct_f64 {
390 return .{ .a = 2.5 };
391}
392
393export fn zig_struct_f64(s: Struct_f64) void {
394 expect(s.a == 2.5) catch @panic("test failure");
395}
396
397extern fn c_ret_struct_f64() Struct_f64;
398
399extern fn c_struct_f64(Struct_f64) void;
400
401test "C ABI struct f64" {
402 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
403 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
404 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
405 if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
406 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
407
408 const s = c_ret_struct_f64();
409 try expect(s.a == 2.5);
410 c_struct_f64(.{ .a = 2.5 });
411}
412
413const Struct_f32f32_f32 = extern struct {
414 a: extern struct { b: f32, c: f32 },
415 d: f32,
416};
417
418export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 {
419 return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 };
420}
421
422export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void {
423 expect(s.a.b == 1.0) catch @panic("test failure");
424 expect(s.a.c == 2.0) catch @panic("test failure");
425 expect(s.d == 3.0) catch @panic("test failure");
426}
427
428extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32;
429
430extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void;
431
432test "C ABI struct {f32,f32} f32" {
433 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
434 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
435 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
436 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
437 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
438 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
439
440 const s = c_ret_struct_f32f32_f32();
441 try expect(s.a.b == 1.0);
442 try expect(s.a.c == 2.0);
443 try expect(s.d == 3.0);
444 c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 });
445}
446
447const Struct_f32_f32f32 = extern struct {
448 a: f32,
449 b: extern struct { c: f32, d: f32 },
450};
451
452export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 {
453 return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } };
454}
455
456export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void {
457 expect(s.a == 1.0) catch @panic("test failure");
458 expect(s.b.c == 2.0) catch @panic("test failure");
459 expect(s.b.d == 3.0) catch @panic("test failure");
460}
461
462extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32;
463
464extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void;
465
466test "C ABI struct f32 {f32,f32}" {
467 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
468 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
469 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
470 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
471 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
472 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
473
474 const s = c_ret_struct_f32_f32f32();
475 try expect(s.a == 1.0);
476 try expect(s.b.c == 2.0);
477 try expect(s.b.d == 3.0);
478 c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } });
479}
480
481const Struct_u32_Union_u32_u32u32 = extern struct {
482 a: u32,
483 b: extern union {
484 c: extern struct {
485 d: u32,
486 e: u32,
487 },
488 },
489};
490
491export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 {
492 return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } };
493}
494
495export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void {
496 expect(s.a == 1) catch @panic("test failure");
497 expect(s.b.c.d == 2) catch @panic("test failure");
498 expect(s.b.c.e == 3) catch @panic("test failure");
499}
500
501extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32;
502
503extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void;
504
505test "C ABI struct{u32,union{u32,struct{u32,u32}}}" {
506 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
507 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
508 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
509 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
510 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
511
512 const s = c_ret_struct_u32_union_u32_u32u32();
513 try expect(s.a == 1);
514 try expect(s.b.c.d == 2);
515 try expect(s.b.c.e == 3);
516 c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } });
517}
518
519const Struct_i32_i32 = extern struct {
520 a: i32,
521 b: i32,
522};
523extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32;
524extern fn c_struct_i32_i32(Struct_i32_i32) void;
525
526test "C ABI struct i32 i32" {
527 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
528 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
529 if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
530 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
531 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
532
533 const s: Struct_i32_i32 = .{
534 .a = 1,
535 .b = 2,
536 };
537 const mut_res = c_mut_struct_i32_i32(s);
538 try expect(s.a == 1);
539 try expect(s.b == 2);
540 try expect(mut_res.a == 101);
541 try expect(mut_res.b == 252);
542 c_struct_i32_i32(s);
543}
544
545export fn zig_struct_i32_i32(s: Struct_i32_i32) void {
546 expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1");
547 expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2");
548}
549
550const BigStruct = extern struct {
551 a: u64,
552 b: u64,
553 c: u64,
554 d: u64,
555 e: u8,
556};
557extern fn c_big_struct(BigStruct) void;
558
559test "C ABI big struct" {
560 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
561 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
562 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
563 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
564 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
565
566 const s = BigStruct{
567 .a = 1,
568 .b = 2,
569 .c = 3,
570 .d = 4,
571 .e = 5,
572 };
573 c_big_struct(s);
574}
575
576export fn zig_big_struct(x: BigStruct) void {
577 expect(x.a == 1) catch @panic("test failure: zig_big_struct 1");
578 expect(x.b == 2) catch @panic("test failure: zig_big_struct 2");
579 expect(x.c == 3) catch @panic("test failure: zig_big_struct 3");
580 expect(x.d == 4) catch @panic("test failure: zig_big_struct 4");
581 expect(x.e == 5) catch @panic("test failure: zig_big_struct 5");
582}
583
584const BigUnion = extern union {
585 a: BigStruct,
586};
587extern fn c_big_union(BigUnion) void;
588
589test "C ABI big union" {
590 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
591 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
592 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
593 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
594
595 const x = BigUnion{
596 .a = BigStruct{
597 .a = 1,
598 .b = 2,
599 .c = 3,
600 .d = 4,
601 .e = 5,
602 },
603 };
604 c_big_union(x);
605}
606
607export fn zig_big_union(x: BigUnion) void {
608 expect(x.a.a == 1) catch @panic("test failure: zig_big_union a");
609 expect(x.a.b == 2) catch @panic("test failure: zig_big_union b");
610 expect(x.a.c == 3) catch @panic("test failure: zig_big_union c");
611 expect(x.a.d == 4) catch @panic("test failure: zig_big_union d");
612 expect(x.a.e == 5) catch @panic("test failure: zig_big_union e");
613}
614
615const MedStructMixed = extern struct {
616 a: u32,
617 b: f32,
618 c: f32,
619 d: u32 = 0,
620};
621extern fn c_med_struct_mixed(MedStructMixed) void;
622extern fn c_ret_med_struct_mixed() MedStructMixed;
623
624test "C ABI medium struct of ints and floats" {
625 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
626 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
627 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
628 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
629 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
630
631 const s = MedStructMixed{
632 .a = 1234,
633 .b = 100.0,
634 .c = 1337.0,
635 };
636 c_med_struct_mixed(s);
637 const s2 = c_ret_med_struct_mixed();
638 try expect(s2.a == 1234);
639 try expect(s2.b == 100.0);
640 try expect(s2.c == 1337.0);
641}
642
643export fn zig_med_struct_mixed(x: MedStructMixed) void {
644 expect(x.a == 1234) catch @panic("test failure");
645 expect(x.b == 100.0) catch @panic("test failure");
646 expect(x.c == 1337.0) catch @panic("test failure");
647}
648
649const SmallStructInts = extern struct {
650 a: u8,
651 b: u8,
652 c: u8,
653 d: u8,
654};
655extern fn c_small_struct_ints(SmallStructInts) void;
656extern fn c_ret_small_struct_ints() SmallStructInts;
657
658test "C ABI small struct of ints" {
659 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
660 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
661 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
662 if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest;
663 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
664 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
665 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
666
667 const s = SmallStructInts{
668 .a = 1,
669 .b = 2,
670 .c = 3,
671 .d = 4,
672 };
673 c_small_struct_ints(s);
674 const s2 = c_ret_small_struct_ints();
675 try expect(s2.a == 1);
676 try expect(s2.b == 2);
677 try expect(s2.c == 3);
678 try expect(s2.d == 4);
679}
680
681export fn zig_small_struct_ints(x: SmallStructInts) void {
682 expect(x.a == 1) catch @panic("test failure");
683 expect(x.b == 2) catch @panic("test failure");
684 expect(x.c == 3) catch @panic("test failure");
685 expect(x.d == 4) catch @panic("test failure");
686}
687
688const MedStructInts = extern struct {
689 x: i32,
690 y: i32,
691 z: i32,
692};
693extern fn c_med_struct_ints(MedStructInts) void;
694extern fn c_ret_med_struct_ints() MedStructInts;
695
696test "C ABI medium struct of ints" {
697 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
698 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
699 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
700 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
701 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
702
703 const s = MedStructInts{
704 .x = 1,
705 .y = 2,
706 .z = 3,
707 };
708 c_med_struct_ints(s);
709 const s2 = c_ret_med_struct_ints();
710 try expect(s2.x == 1);
711 try expect(s2.y == 2);
712 try expect(s2.z == 3);
713}
714
715export fn zig_med_struct_ints(s: MedStructInts) void {
716 expect(s.x == 1) catch @panic("test failure");
717 expect(s.y == 2) catch @panic("test failure");
718 expect(s.z == 3) catch @panic("test failure");
719}
720
721const SmallPackedStruct = packed struct {
722 a: u2,
723 b: u2,
724 c: u2,
725 d: u2,
726};
727extern fn c_small_packed_struct(SmallPackedStruct) void;
728extern fn c_ret_small_packed_struct() SmallPackedStruct;
729
730export fn zig_small_packed_struct(x: SmallPackedStruct) void {
731 expect(x.a == 0) catch @panic("test failure");
732 expect(x.b == 1) catch @panic("test failure");
733 expect(x.c == 2) catch @panic("test failure");
734 expect(x.d == 3) catch @panic("test failure");
735}
736
737test "C ABI small packed struct" {
738 const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 };
739 c_small_packed_struct(s);
740 const s2 = c_ret_small_packed_struct();
741 try expect(s2.a == 0);
742 try expect(s2.b == 1);
743 try expect(s2.c == 2);
744 try expect(s2.d == 3);
745}
746
747const BigPackedStruct = packed struct {
748 a: u64,
749 b: u64,
750};
751extern fn c_big_packed_struct(BigPackedStruct) void;
752extern fn c_ret_big_packed_struct() BigPackedStruct;
753
754export fn zig_big_packed_struct(x: BigPackedStruct) void {
755 expect(x.a == 1) catch @panic("test failure");
756 expect(x.b == 2) catch @panic("test failure");
757}
758
759test "C ABI big packed struct" {
760 if (!have_i128) return error.SkipZigTest;
761
762 const s = BigPackedStruct{ .a = 1, .b = 2 };
763 c_big_packed_struct(s);
764 const s2 = c_ret_big_packed_struct();
765 try expect(s2.a == 1);
766 try expect(s2.b == 2);
767}
768
769const SplitStructInt = extern struct {
770 a: u64,
771 b: u8,
772 c: u32,
773};
774extern fn c_split_struct_ints(SplitStructInt) void;
775
776test "C ABI split struct of ints" {
777 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
778 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
779 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
780 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
781 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
782 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
783
784 const s = SplitStructInt{
785 .a = 1234,
786 .b = 100,
787 .c = 1337,
788 };
789 c_split_struct_ints(s);
790}
791
792export fn zig_split_struct_ints(x: SplitStructInt) void {
793 expect(x.a == 1234) catch @panic("test failure");
794 expect(x.b == 100) catch @panic("test failure");
795 expect(x.c == 1337) catch @panic("test failure");
796}
797
798const SplitStructMixed = extern struct {
799 a: u64,
800 b: u8,
801 c: f32,
802};
803extern fn c_split_struct_mixed(SplitStructMixed) void;
804extern fn c_ret_split_struct_mixed() SplitStructMixed;
805
806test "C ABI split struct of ints and floats" {
807 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
808 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
809 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
810 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
811 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
812 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
813
814 const s = SplitStructMixed{
815 .a = 1234,
816 .b = 100,
817 .c = 1337.0,
818 };
819 c_split_struct_mixed(s);
820 const s2 = c_ret_split_struct_mixed();
821 try expect(s2.a == 1234);
822 try expect(s2.b == 100);
823 try expect(s2.c == 1337.0);
824}
825
826export fn zig_split_struct_mixed(x: SplitStructMixed) void {
827 expect(x.a == 1234) catch @panic("test failure");
828 expect(x.b == 100) catch @panic("test failure");
829 expect(x.c == 1337.0) catch @panic("test failure");
830}
831
832extern fn c_big_struct_both(BigStruct) BigStruct;
833
834extern fn c_multiple_struct_ints(Rect, Rect) void;
835extern fn c_multiple_struct_floats(FloatRect, FloatRect) void;
836
837test "C ABI sret and byval together" {
838 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
839 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
840 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
841 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
842 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
843
844 const s = BigStruct{
845 .a = 1,
846 .b = 2,
847 .c = 3,
848 .d = 4,
849 .e = 5,
850 };
851 const y = c_big_struct_both(s);
852 try expect(y.a == 10);
853 try expect(y.b == 11);
854 try expect(y.c == 12);
855 try expect(y.d == 13);
856 try expect(y.e == 14);
857}
858
859export fn zig_big_struct_both(x: BigStruct) BigStruct {
860 expect(x.a == 30) catch @panic("test failure");
861 expect(x.b == 31) catch @panic("test failure");
862 expect(x.c == 32) catch @panic("test failure");
863 expect(x.d == 33) catch @panic("test failure");
864 expect(x.e == 34) catch @panic("test failure");
865 const s = BigStruct{
866 .a = 20,
867 .b = 21,
868 .c = 22,
869 .d = 23,
870 .e = 24,
871 };
872 return s;
873}
874
875const Vector3 = extern struct {
876 x: f32,
877 y: f32,
878 z: f32,
879};
880extern fn c_small_struct_floats(Vector3) void;
881extern fn c_small_struct_floats_extra(Vector3, ?[*]const u8) void;
882
883const Vector5 = extern struct {
884 x: f32,
885 y: f32,
886 z: f32,
887 w: f32,
888 q: f32,
889};
890extern fn c_big_struct_floats(Vector5) void;
891
892test "C ABI structs of floats as parameter" {
893 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
894 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
895 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
896 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
897 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
898
899 const v3 = Vector3{
900 .x = 3.0,
901 .y = 6.0,
902 .z = 12.0,
903 };
904 c_small_struct_floats(v3);
905 c_small_struct_floats_extra(v3, "hello");
906
907 const v5 = Vector5{
908 .x = 76.0,
909 .y = -1.0,
910 .z = -12.0,
911 .w = 69.0,
912 .q = 55,
913 };
914 c_big_struct_floats(v5);
915}
916
917const Rect = extern struct {
918 left: u32,
919 right: u32,
920 top: u32,
921 bottom: u32,
922};
923
924export fn zig_multiple_struct_ints(x: Rect, y: Rect) void {
925 expect(x.left == 1) catch @panic("test failure");
926 expect(x.right == 21) catch @panic("test failure");
927 expect(x.top == 16) catch @panic("test failure");
928 expect(x.bottom == 4) catch @panic("test failure");
929 expect(y.left == 178) catch @panic("test failure");
930 expect(y.right == 189) catch @panic("test failure");
931 expect(y.top == 21) catch @panic("test failure");
932 expect(y.bottom == 15) catch @panic("test failure");
933}
934
935test "C ABI structs of ints as multiple parameters" {
936 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
937 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
938 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
939 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
940 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
941
942 const r1 = Rect{
943 .left = 1,
944 .right = 21,
945 .top = 16,
946 .bottom = 4,
947 };
948 const r2 = Rect{
949 .left = 178,
950 .right = 189,
951 .top = 21,
952 .bottom = 15,
953 };
954 c_multiple_struct_ints(r1, r2);
955}
956
957const FloatRect = extern struct {
958 left: f32,
959 right: f32,
960 top: f32,
961 bottom: f32,
962};
963
964export fn zig_multiple_struct_floats(x: FloatRect, y: FloatRect) void {
965 expect(x.left == 1) catch @panic("test failure");
966 expect(x.right == 21) catch @panic("test failure");
967 expect(x.top == 16) catch @panic("test failure");
968 expect(x.bottom == 4) catch @panic("test failure");
969 expect(y.left == 178) catch @panic("test failure");
970 expect(y.right == 189) catch @panic("test failure");
971 expect(y.top == 21) catch @panic("test failure");
972 expect(y.bottom == 15) catch @panic("test failure");
973}
974
975test "C ABI structs of floats as multiple parameters" {
976 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
977 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
978 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
979 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
980 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
981
982 const r1 = FloatRect{
983 .left = 1,
984 .right = 21,
985 .top = 16,
986 .bottom = 4,
987 };
988 const r2 = FloatRect{
989 .left = 178,
990 .right = 189,
991 .top = 21,
992 .bottom = 15,
993 };
994 c_multiple_struct_floats(r1, r2);
995}
996
997export fn zig_ret_bool() bool {
998 return true;
999}
1000export fn zig_ret_u8() u8 {
1001 return 0xff;
1002}
1003export fn zig_ret_u16() u16 {
1004 return 0xffff;
1005}
1006export fn zig_ret_u32() u32 {
1007 return 0xffffffff;
1008}
1009export fn zig_ret_u64() u64 {
1010 return 0xffffffffffffffff;
1011}
1012export fn zig_ret_i8() i8 {
1013 return -1;
1014}
1015export fn zig_ret_i16() i16 {
1016 return -1;
1017}
1018export fn zig_ret_i32() i32 {
1019 return -1;
1020}
1021export fn zig_ret_i64() i64 {
1022 return -1;
1023}
1024
1025export fn zig_ret_small_struct_ints() SmallStructInts {
1026 return .{
1027 .a = 1,
1028 .b = 2,
1029 .c = 3,
1030 .d = 4,
1031 };
1032}
1033
1034export fn zig_ret_med_struct_ints() MedStructInts {
1035 return .{
1036 .x = 1,
1037 .y = 2,
1038 .z = 3,
1039 };
1040}
1041
1042export fn zig_ret_med_struct_mixed() MedStructMixed {
1043 return .{
1044 .a = 1234,
1045 .b = 100.0,
1046 .c = 1337.0,
1047 };
1048}
1049
1050export fn zig_ret_split_struct_mixed() SplitStructMixed {
1051 return .{
1052 .a = 1234,
1053 .b = 100,
1054 .c = 1337.0,
1055 };
1056}
1057
1058extern fn c_ret_bool() bool;
1059extern fn c_ret_u8() u8;
1060extern fn c_ret_u16() u16;
1061extern fn c_ret_u32() u32;
1062extern fn c_ret_u64() u64;
1063extern fn c_ret_i8() i8;
1064extern fn c_ret_i16() i16;
1065extern fn c_ret_i32() i32;
1066extern fn c_ret_i64() i64;
1067
1068test "C ABI integer return types" {
1069 try expect(c_ret_bool() == true);
1070
1071 try expect(c_ret_u8() == 0xff);
1072 try expect(c_ret_u16() == 0xffff);
1073 try expect(c_ret_u32() == 0xffffffff);
1074 try expect(c_ret_u64() == 0xffffffffffffffff);
1075
1076 try expect(c_ret_i8() == -1);
1077 try expect(c_ret_i16() == -1);
1078 try expect(c_ret_i32() == -1);
1079 try expect(c_ret_i64() == -1);
1080}
1081
1082const StructWithArray = extern struct {
1083 a: i32,
1084 padding: [4]u8,
1085 b: i64,
1086};
1087extern fn c_struct_with_array(StructWithArray) void;
1088extern fn c_ret_struct_with_array() StructWithArray;
1089
1090test "Struct with array as padding." {
1091 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
1092 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1093 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1094 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1095 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1096 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1097
1098 c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 });
1099
1100 const x = c_ret_struct_with_array();
1101 try expect(x.a == 4);
1102 try expect(x.b == 155);
1103}
1104
1105const FloatArrayStruct = extern struct {
1106 origin: extern struct {
1107 x: f64,
1108 y: f64,
1109 },
1110 size: extern struct {
1111 width: f64,
1112 height: f64,
1113 },
1114};
1115
1116extern fn c_float_array_struct(FloatArrayStruct) void;
1117extern fn c_ret_float_array_struct() FloatArrayStruct;
1118
1119test "Float array like struct" {
1120 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1121 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
1122 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1123 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1124 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1125
1126 c_float_array_struct(.{
1127 .origin = .{
1128 .x = 5,
1129 .y = 6,
1130 },
1131 .size = .{
1132 .width = 7,
1133 .height = 8,
1134 },
1135 });
1136
1137 const x = c_ret_float_array_struct();
1138 try expect(x.origin.x == 1);
1139 try expect(x.origin.y == 2);
1140 try expect(x.size.width == 3);
1141 try expect(x.size.height == 4);
1142}
1143
1144const SmallVec = @Vector(2, u32);
1145
1146extern fn c_small_vec(SmallVec) void;
1147extern fn c_ret_small_vec() SmallVec;
1148
1149test "small simd vector" {
1150 if (builtin.cpu.arch == .x86) return error.SkipZigTest;
1151 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1152 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1153 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1154
1155 c_small_vec(.{ 1, 2 });
1156
1157 const x = c_ret_small_vec();
1158 try expect(x[0] == 3);
1159 try expect(x[1] == 4);
1160}
1161
1162const MediumVec = @Vector(4, usize);
1163
1164extern fn c_medium_vec(MediumVec) void;
1165extern fn c_ret_medium_vec() MediumVec;
1166
1167test "medium simd vector" {
1168 if (builtin.zig_backend == .stage2_x86_64 and !comptime builtin.cpu.has(.x86, .avx)) return error.SkipZigTest;
1169 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1170 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1171 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1172
1173 c_medium_vec(.{ 1, 2, 3, 4 });
1174
1175 const x = c_ret_medium_vec();
1176 try expect(x[0] == 5);
1177 try expect(x[1] == 6);
1178 try expect(x[2] == 7);
1179 try expect(x[3] == 8);
1180}
1181
1182const BigVec = @Vector(8, usize);
1183
1184extern fn c_big_vec(BigVec) void;
1185extern fn c_ret_big_vec() BigVec;
1186
1187test "big simd vector" {
1188 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1189
1190 if (builtin.cpu.arch.isMIPS64() and builtin.mode != .Debug) return error.SkipZigTest;
1191 if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1192 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1193 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag.isDarwin() and builtin.mode != .Debug) return error.SkipZigTest;
1194 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1195
1196 c_big_vec(.{ 1, 2, 3, 4, 5, 6, 7, 8 });
1197
1198 const x = c_ret_big_vec();
1199 try expect(x[0] == 9);
1200 try expect(x[1] == 10);
1201 try expect(x[2] == 11);
1202 try expect(x[3] == 12);
1203 try expect(x[4] == 13);
1204 try expect(x[5] == 14);
1205 try expect(x[6] == 15);
1206 try expect(x[7] == 16);
1207}
1208
1209const Vector2Float = @Vector(2, f32);
1210const Vector4Float = @Vector(4, f32);
1211
1212extern fn c_vector_2_float(Vector2Float) void;
1213extern fn c_vector_4_float(Vector4Float) void;
1214
1215extern fn c_ret_vector_2_float() Vector2Float;
1216extern fn c_ret_vector_4_float() Vector4Float;
1217
1218test "float simd vectors" {
1219 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1220 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1221 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1222
1223 {
1224 c_vector_2_float(.{ 1.0, 2.0 });
1225 const vec = c_ret_vector_2_float();
1226 try expect(vec[0] == 1.0);
1227 try expect(vec[1] == 2.0);
1228 }
1229 {
1230 c_vector_4_float(.{ 1.0, 2.0, 3.0, 4.0 });
1231 const vec = c_ret_vector_4_float();
1232 try expect(vec[0] == 1.0);
1233 try expect(vec[1] == 2.0);
1234 try expect(vec[2] == 3.0);
1235 try expect(vec[3] == 4.0);
1236 }
1237}
1238
1239const Vector2Bool = @Vector(2, bool);
1240const Vector4Bool = @Vector(4, bool);
1241const Vector8Bool = @Vector(8, bool);
1242const Vector16Bool = @Vector(16, bool);
1243const Vector32Bool = @Vector(32, bool);
1244const Vector64Bool = @Vector(64, bool);
1245const Vector128Bool = @Vector(128, bool);
1246const Vector256Bool = @Vector(256, bool);
1247const Vector512Bool = @Vector(512, bool);
1248
1249extern fn c_vector_2_bool(Vector2Bool) void;
1250extern fn c_vector_4_bool(Vector4Bool) void;
1251extern fn c_vector_8_bool(Vector8Bool) void;
1252extern fn c_vector_16_bool(Vector16Bool) void;
1253extern fn c_vector_32_bool(Vector32Bool) void;
1254extern fn c_vector_64_bool(Vector64Bool) void;
1255extern fn c_vector_128_bool(Vector128Bool) void;
1256extern fn c_vector_256_bool(Vector256Bool) void;
1257extern fn c_vector_512_bool(Vector512Bool) void;
1258
1259extern fn c_ret_vector_2_bool() Vector2Bool;
1260extern fn c_ret_vector_4_bool() Vector4Bool;
1261extern fn c_ret_vector_8_bool() Vector8Bool;
1262extern fn c_ret_vector_16_bool() Vector16Bool;
1263extern fn c_ret_vector_32_bool() Vector32Bool;
1264extern fn c_ret_vector_64_bool() Vector64Bool;
1265extern fn c_ret_vector_128_bool() Vector128Bool;
1266extern fn c_ret_vector_256_bool() Vector256Bool;
1267extern fn c_ret_vector_512_bool() Vector512Bool;
1268
1269test "bool simd vector" {
1270 if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
1271
1272 {
1273 c_vector_2_bool(.{
1274 true,
1275 true,
1276 });
1277
1278 const vec = c_ret_vector_2_bool();
1279 try expect(vec[0] == true);
1280 try expect(vec[1] == false);
1281 }
1282 {
1283 c_vector_4_bool(.{
1284 true,
1285 true,
1286 false,
1287 true,
1288 });
1289
1290 const vec = c_ret_vector_4_bool();
1291 try expect(vec[0] == true);
1292 try expect(vec[1] == false);
1293 try expect(vec[2] == true);
1294 try expect(vec[3] == false);
1295 }
1296 {
1297 c_vector_8_bool(.{
1298 true,
1299 false,
1300 true,
1301 true,
1302 true,
1303 true,
1304 false,
1305 true,
1306 });
1307
1308 const vec = c_ret_vector_8_bool();
1309 try expect(vec[0] == false);
1310 try expect(vec[1] == true);
1311 try expect(vec[2] == false);
1312 try expect(vec[3] == false);
1313 try expect(vec[4] == true);
1314 try expect(vec[5] == false);
1315 try expect(vec[6] == false);
1316 try expect(vec[7] == true);
1317 }
1318 {
1319 c_vector_16_bool(.{
1320 true,
1321 false,
1322 false,
1323 false,
1324 true,
1325 false,
1326 true,
1327 true,
1328 true,
1329 true,
1330 true,
1331 true,
1332 false,
1333 false,
1334 false,
1335 false,
1336 });
1337
1338 const vec = c_ret_vector_16_bool();
1339 try expect(vec[0] == true);
1340 try expect(vec[1] == true);
1341 try expect(vec[2] == false);
1342 try expect(vec[3] == false);
1343 try expect(vec[4] == false);
1344 try expect(vec[5] == false);
1345 try expect(vec[6] == true);
1346 try expect(vec[7] == false);
1347 try expect(vec[8] == true);
1348 try expect(vec[9] == false);
1349 try expect(vec[10] == false);
1350 try expect(vec[11] == true);
1351 try expect(vec[12] == true);
1352 try expect(vec[13] == false);
1353 try expect(vec[14] == true);
1354 try expect(vec[15] == true);
1355 }
1356 {
1357 c_vector_32_bool(.{
1358 true,
1359 false,
1360 true,
1361 true,
1362 false,
1363 false,
1364 true,
1365 false,
1366 true,
1367 false,
1368 true,
1369 true,
1370 true,
1371 false,
1372 false,
1373 true,
1374 false,
1375 true,
1376 false,
1377 true,
1378 true,
1379 true,
1380 true,
1381 true,
1382 false,
1383 true,
1384 true,
1385 true,
1386 false,
1387 true,
1388 true,
1389 false,
1390 });
1391
1392 const vec = c_ret_vector_32_bool();
1393 try expect(vec[0] == true);
1394 try expect(vec[1] == false);
1395 try expect(vec[2] == true);
1396 try expect(vec[3] == true);
1397 try expect(vec[4] == true);
1398 try expect(vec[5] == false);
1399 try expect(vec[6] == true);
1400 try expect(vec[7] == false);
1401 try expect(vec[8] == true);
1402 try expect(vec[9] == true);
1403 try expect(vec[10] == true);
1404 try expect(vec[11] == false);
1405 try expect(vec[12] == true);
1406 try expect(vec[13] == true);
1407 try expect(vec[14] == false);
1408 try expect(vec[15] == false);
1409 try expect(vec[16] == true);
1410 try expect(vec[17] == false);
1411 try expect(vec[18] == false);
1412 try expect(vec[19] == false);
1413 try expect(vec[20] == false);
1414 try expect(vec[21] == true);
1415 try expect(vec[22] == true);
1416 try expect(vec[23] == true);
1417 try expect(vec[24] == false);
1418 try expect(vec[25] == true);
1419 try expect(vec[26] == false);
1420 try expect(vec[27] == false);
1421 try expect(vec[28] == true);
1422 try expect(vec[29] == false);
1423 try expect(vec[30] == false);
1424 try expect(vec[31] == false);
1425 }
1426 {
1427 c_vector_64_bool(.{
1428 true,
1429 true,
1430 true,
1431 false,
1432 true,
1433 false,
1434 false,
1435 false,
1436 true,
1437 false,
1438 false,
1439 false,
1440 false,
1441 true,
1442 true,
1443 true,
1444 true,
1445 false,
1446 false,
1447 true,
1448 false,
1449 true,
1450 false,
1451 true,
1452 true,
1453 true,
1454 true,
1455 true,
1456 true,
1457 true,
1458 false,
1459 false,
1460 true,
1461 true,
1462 false,
1463 true,
1464 false,
1465 false,
1466 true,
1467 true,
1468 true,
1469 false,
1470 false,
1471 true,
1472 true,
1473 false,
1474 true,
1475 false,
1476 true,
1477 false,
1478 false,
1479 true,
1480 false,
1481 true,
1482 true,
1483 true,
1484 true,
1485 true,
1486 false,
1487 false,
1488 true,
1489 false,
1490 true,
1491 false,
1492 });
1493
1494 const vec = c_ret_vector_64_bool();
1495 try expect(vec[0] == false);
1496 try expect(vec[1] == true);
1497 try expect(vec[2] == false);
1498 try expect(vec[3] == true);
1499 try expect(vec[4] == true);
1500 try expect(vec[5] == true);
1501 try expect(vec[6] == false);
1502 try expect(vec[7] == true);
1503 try expect(vec[8] == true);
1504 try expect(vec[9] == true);
1505 try expect(vec[10] == true);
1506 try expect(vec[11] == true);
1507 try expect(vec[12] == true);
1508 try expect(vec[13] == false);
1509 try expect(vec[14] == true);
1510 try expect(vec[15] == true);
1511 try expect(vec[16] == true);
1512 try expect(vec[17] == false);
1513 try expect(vec[18] == false);
1514 try expect(vec[19] == false);
1515 try expect(vec[20] == true);
1516 try expect(vec[21] == true);
1517 try expect(vec[22] == false);
1518 try expect(vec[23] == true);
1519 try expect(vec[24] == false);
1520 try expect(vec[25] == true);
1521 try expect(vec[26] == false);
1522 try expect(vec[27] == true);
1523 try expect(vec[28] == false);
1524 try expect(vec[29] == true);
1525 try expect(vec[30] == false);
1526 try expect(vec[31] == true);
1527 try expect(vec[32] == false);
1528 try expect(vec[33] == false);
1529 try expect(vec[34] == true);
1530 try expect(vec[35] == true);
1531 try expect(vec[36] == false);
1532 try expect(vec[37] == false);
1533 try expect(vec[38] == false);
1534 try expect(vec[39] == true);
1535 try expect(vec[40] == true);
1536 try expect(vec[41] == true);
1537 try expect(vec[42] == true);
1538 try expect(vec[43] == false);
1539 try expect(vec[44] == false);
1540 try expect(vec[45] == false);
1541 try expect(vec[46] == true);
1542 try expect(vec[47] == true);
1543 try expect(vec[48] == false);
1544 try expect(vec[49] == false);
1545 try expect(vec[50] == true);
1546 try expect(vec[51] == false);
1547 try expect(vec[52] == false);
1548 try expect(vec[53] == false);
1549 try expect(vec[54] == false);
1550 try expect(vec[55] == true);
1551 try expect(vec[56] == false);
1552 try expect(vec[57] == false);
1553 try expect(vec[58] == false);
1554 try expect(vec[59] == true);
1555 try expect(vec[60] == true);
1556 try expect(vec[61] == true);
1557 try expect(vec[62] == true);
1558 try expect(vec[63] == true);
1559 }
1560 {
1561 c_vector_128_bool(.{
1562 false,
1563 false,
1564 false,
1565 false,
1566 false,
1567 true,
1568 true,
1569 false,
1570 true,
1571 true,
1572 false,
1573 true,
1574 true,
1575 false,
1576 true,
1577 true,
1578 true,
1579 false,
1580 false,
1581 false,
1582 false,
1583 true,
1584 true,
1585 false,
1586 false,
1587 false,
1588 true,
1589 true,
1590 false,
1591 true,
1592 false,
1593 false,
1594 true,
1595 false,
1596 false,
1597 true,
1598 true,
1599 true,
1600 true,
1601 true,
1602 false,
1603 true,
1604 true,
1605 true,
1606 false,
1607 false,
1608 false,
1609 false,
1610 true,
1611 true,
1612 false,
1613 true,
1614 true,
1615 true,
1616 true,
1617 true,
1618 false,
1619 true,
1620 true,
1621 false,
1622 true,
1623 false,
1624 false,
1625 true,
1626 true,
1627 false,
1628 true,
1629 true,
1630 false,
1631 true,
1632 false,
1633 false,
1634 true,
1635 true,
1636 false,
1637 true,
1638 true,
1639 true,
1640 false,
1641 true,
1642 false,
1643 false,
1644 false,
1645 false,
1646 true,
1647 false,
1648 false,
1649 false,
1650 true,
1651 true,
1652 false,
1653 false,
1654 true,
1655 true,
1656 true,
1657 true,
1658 false,
1659 false,
1660 false,
1661 false,
1662 false,
1663 true,
1664 false,
1665 false,
1666 false,
1667 false,
1668 true,
1669 true,
1670 true,
1671 true,
1672 true,
1673 false,
1674 false,
1675 true,
1676 false,
1677 true,
1678 false,
1679 false,
1680 true,
1681 false,
1682 true,
1683 false,
1684 true,
1685 true,
1686 true,
1687 true,
1688 true,
1689 true,
1690 });
1691
1692 const vec = c_ret_vector_128_bool();
1693 try expect(vec[0] == false);
1694 try expect(vec[1] == true);
1695 try expect(vec[2] == true);
1696 try expect(vec[3] == false);
1697 try expect(vec[4] == true);
1698 try expect(vec[5] == false);
1699 try expect(vec[6] == false);
1700 try expect(vec[7] == true);
1701 try expect(vec[8] == true);
1702 try expect(vec[9] == false);
1703 try expect(vec[10] == true);
1704 try expect(vec[11] == false);
1705 try expect(vec[12] == false);
1706 try expect(vec[13] == false);
1707 try expect(vec[14] == true);
1708 try expect(vec[15] == false);
1709 try expect(vec[16] == true);
1710 try expect(vec[17] == false);
1711 try expect(vec[18] == false);
1712 try expect(vec[19] == true);
1713 try expect(vec[20] == false);
1714 try expect(vec[21] == true);
1715 try expect(vec[22] == false);
1716 try expect(vec[23] == false);
1717 try expect(vec[24] == false);
1718 try expect(vec[25] == true);
1719 try expect(vec[26] == true);
1720 try expect(vec[27] == true);
1721 try expect(vec[28] == false);
1722 try expect(vec[29] == false);
1723 try expect(vec[30] == false);
1724 try expect(vec[31] == false);
1725 try expect(vec[32] == true);
1726 try expect(vec[33] == true);
1727 try expect(vec[34] == true);
1728 try expect(vec[35] == false);
1729 try expect(vec[36] == true);
1730 try expect(vec[37] == true);
1731 try expect(vec[38] == false);
1732 try expect(vec[39] == false);
1733 try expect(vec[40] == false);
1734 try expect(vec[41] == false);
1735 try expect(vec[42] == true);
1736 try expect(vec[43] == true);
1737 try expect(vec[44] == true);
1738 try expect(vec[45] == false);
1739 try expect(vec[46] == false);
1740 try expect(vec[47] == false);
1741 try expect(vec[48] == false);
1742 try expect(vec[49] == true);
1743 try expect(vec[50] == false);
1744 try expect(vec[51] == false);
1745 try expect(vec[52] == true);
1746 try expect(vec[53] == false);
1747 try expect(vec[54] == false);
1748 try expect(vec[55] == false);
1749 try expect(vec[56] == false);
1750 try expect(vec[57] == false);
1751 try expect(vec[58] == true);
1752 try expect(vec[59] == true);
1753 try expect(vec[60] == true);
1754 try expect(vec[61] == false);
1755 try expect(vec[62] == true);
1756 try expect(vec[63] == true);
1757 try expect(vec[64] == false);
1758 try expect(vec[65] == false);
1759 try expect(vec[66] == false);
1760 try expect(vec[67] == false);
1761 try expect(vec[68] == false);
1762 try expect(vec[69] == false);
1763 try expect(vec[70] == false);
1764 try expect(vec[71] == false);
1765 try expect(vec[72] == true);
1766 try expect(vec[73] == true);
1767 try expect(vec[74] == true);
1768 try expect(vec[75] == true);
1769 try expect(vec[76] == true);
1770 try expect(vec[77] == false);
1771 try expect(vec[78] == false);
1772 try expect(vec[79] == false);
1773 try expect(vec[80] == false);
1774 try expect(vec[81] == false);
1775 try expect(vec[82] == false);
1776 try expect(vec[83] == true);
1777 try expect(vec[84] == false);
1778 try expect(vec[85] == true);
1779 try expect(vec[86] == false);
1780 try expect(vec[87] == true);
1781 try expect(vec[88] == false);
1782 try expect(vec[89] == true);
1783 try expect(vec[90] == false);
1784 try expect(vec[91] == true);
1785 try expect(vec[92] == true);
1786 try expect(vec[93] == true);
1787 try expect(vec[94] == true);
1788 try expect(vec[95] == false);
1789 try expect(vec[96] == false);
1790 try expect(vec[97] == true);
1791 try expect(vec[98] == false);
1792 try expect(vec[99] == false);
1793 try expect(vec[100] == true);
1794 try expect(vec[101] == true);
1795 try expect(vec[102] == true);
1796 try expect(vec[103] == true);
1797 try expect(vec[104] == false);
1798 try expect(vec[105] == true);
1799 try expect(vec[106] == true);
1800 try expect(vec[107] == true);
1801 try expect(vec[108] == false);
1802 try expect(vec[109] == false);
1803 try expect(vec[110] == true);
1804 try expect(vec[111] == false);
1805 try expect(vec[112] == false);
1806 try expect(vec[113] == true);
1807 try expect(vec[114] == true);
1808 try expect(vec[115] == false);
1809 try expect(vec[116] == true);
1810 try expect(vec[117] == false);
1811 try expect(vec[118] == true);
1812 try expect(vec[119] == true);
1813 try expect(vec[120] == true);
1814 try expect(vec[121] == true);
1815 try expect(vec[122] == true);
1816 try expect(vec[123] == false);
1817 try expect(vec[124] == false);
1818 try expect(vec[125] == true);
1819 try expect(vec[126] == false);
1820 try expect(vec[127] == true);
1821 }
1822
1823 {
1824 if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{
1825 false,
1826 true,
1827 true,
1828 false,
1829 false,
1830 true,
1831 true,
1832 true,
1833 false,
1834 true,
1835 true,
1836 true,
1837 false,
1838 true,
1839 false,
1840 true,
1841 false,
1842 false,
1843 true,
1844 true,
1845 false,
1846 true,
1847 false,
1848 false,
1849 false,
1850 true,
1851 true,
1852 false,
1853 false,
1854 true,
1855 true,
1856 false,
1857 true,
1858 false,
1859 false,
1860 true,
1861 false,
1862 true,
1863 false,
1864 true,
1865 true,
1866 true,
1867 true,
1868 false,
1869 false,
1870 true,
1871 false,
1872 false,
1873 false,
1874 false,
1875 false,
1876 false,
1877 true,
1878 true,
1879 true,
1880 true,
1881 true,
1882 true,
1883 false,
1884 true,
1885 true,
1886 false,
1887 false,
1888 true,
1889 false,
1890 false,
1891 false,
1892 false,
1893 false,
1894 false,
1895 true,
1896 true,
1897 true,
1898 false,
1899 false,
1900 false,
1901 true,
1902 false,
1903 true,
1904 true,
1905 false,
1906 false,
1907 true,
1908 true,
1909 false,
1910 true,
1911 true,
1912 true,
1913 true,
1914 true,
1915 true,
1916 true,
1917 false,
1918 true,
1919 true,
1920 false,
1921 false,
1922 true,
1923 true,
1924 false,
1925 true,
1926 false,
1927 false,
1928 true,
1929 false,
1930 true,
1931 true,
1932 true,
1933 true,
1934 true,
1935 false,
1936 false,
1937 false,
1938 false,
1939 true,
1940 true,
1941 false,
1942 true,
1943 false,
1944 false,
1945 true,
1946 false,
1947 false,
1948 true,
1949 false,
1950 true,
1951 true,
1952 true,
1953 true,
1954 false,
1955 true,
1956 true,
1957 false,
1958 false,
1959 true,
1960 false,
1961 false,
1962 true,
1963 false,
1964 true,
1965 false,
1966 true,
1967 true,
1968 true,
1969 true,
1970 false,
1971 true,
1972 false,
1973 false,
1974 false,
1975 true,
1976 true,
1977 true,
1978 true,
1979 true,
1980 false,
1981 true,
1982 false,
1983 false,
1984 false,
1985 true,
1986 true,
1987 false,
1988 true,
1989 true,
1990 false,
1991 false,
1992 false,
1993 false,
1994 true,
1995 false,
1996 true,
1997 false,
1998 false,
1999 false,
2000 false,
2001 true,
2002 true,
2003 true,
2004 false,
2005 true,
2006 false,
2007 true,
2008 true,
2009 false,
2010 false,
2011 true,
2012 false,
2013 false,
2014 false,
2015 false,
2016 true,
2017 true,
2018 true,
2019 true,
2020 true,
2021 true,
2022 true,
2023 false,
2024 true,
2025 false,
2026 false,
2027 true,
2028 false,
2029 true,
2030 true,
2031 true,
2032 false,
2033 false,
2034 true,
2035 true,
2036 true,
2037 false,
2038 true,
2039 true,
2040 true,
2041 true,
2042 true,
2043 false,
2044 false,
2045 false,
2046 false,
2047 false,
2048 true,
2049 true,
2050 false,
2051 true,
2052 false,
2053 false,
2054 true,
2055 false,
2056 true,
2057 false,
2058 false,
2059 false,
2060 true,
2061 false,
2062 false,
2063 false,
2064 true,
2065 true,
2066 true,
2067 true,
2068 true,
2069 true,
2070 false,
2071 false,
2072 true,
2073 false,
2074 true,
2075 true,
2076 false,
2077 true,
2078 true,
2079 true,
2080 false,
2081 });
2082
2083 const vec = c_ret_vector_256_bool();
2084 try expect(vec[0] == true);
2085 try expect(vec[1] == false);
2086 try expect(vec[2] == true);
2087 try expect(vec[3] == true);
2088 try expect(vec[4] == false);
2089 try expect(vec[5] == false);
2090 try expect(vec[6] == false);
2091 try expect(vec[7] == false);
2092 try expect(vec[8] == false);
2093 try expect(vec[9] == true);
2094 try expect(vec[10] == false);
2095 try expect(vec[11] == true);
2096 try expect(vec[12] == false);
2097 try expect(vec[13] == true);
2098 try expect(vec[14] == false);
2099 try expect(vec[15] == false);
2100 try expect(vec[16] == true);
2101 try expect(vec[17] == true);
2102 try expect(vec[18] == true);
2103 try expect(vec[19] == false);
2104 try expect(vec[20] == false);
2105 try expect(vec[21] == false);
2106 try expect(vec[22] == true);
2107 try expect(vec[23] == false);
2108 try expect(vec[24] == true);
2109 try expect(vec[25] == false);
2110 try expect(vec[26] == false);
2111 try expect(vec[27] == true);
2112 try expect(vec[28] == true);
2113 try expect(vec[29] == true);
2114 try expect(vec[30] == false);
2115 try expect(vec[31] == false);
2116 try expect(vec[32] == true);
2117 try expect(vec[33] == true);
2118 try expect(vec[34] == true);
2119 try expect(vec[35] == false);
2120 try expect(vec[36] == true);
2121 try expect(vec[37] == true);
2122 try expect(vec[38] == true);
2123 try expect(vec[39] == false);
2124 try expect(vec[40] == true);
2125 try expect(vec[41] == false);
2126 try expect(vec[42] == true);
2127 try expect(vec[43] == true);
2128 try expect(vec[44] == false);
2129 try expect(vec[45] == true);
2130 try expect(vec[46] == false);
2131 try expect(vec[47] == true);
2132 try expect(vec[48] == true);
2133 try expect(vec[49] == false);
2134 try expect(vec[50] == false);
2135 try expect(vec[51] == true);
2136 try expect(vec[52] == true);
2137 try expect(vec[53] == false);
2138 try expect(vec[54] == false);
2139 try expect(vec[55] == true);
2140 try expect(vec[56] == false);
2141 try expect(vec[57] == true);
2142 try expect(vec[58] == true);
2143 try expect(vec[59] == true);
2144 try expect(vec[60] == false);
2145 try expect(vec[61] == true);
2146 try expect(vec[62] == true);
2147 try expect(vec[63] == false);
2148 try expect(vec[64] == true);
2149 try expect(vec[65] == true);
2150 try expect(vec[66] == false);
2151 try expect(vec[67] == true);
2152 try expect(vec[68] == false);
2153 try expect(vec[69] == true);
2154 try expect(vec[70] == true);
2155 try expect(vec[71] == true);
2156 try expect(vec[72] == false);
2157 try expect(vec[73] == true);
2158 try expect(vec[74] == true);
2159 try expect(vec[75] == false);
2160 try expect(vec[76] == true);
2161 try expect(vec[77] == true);
2162 try expect(vec[78] == true);
2163 try expect(vec[79] == true);
2164 try expect(vec[80] == false);
2165 try expect(vec[81] == true);
2166 try expect(vec[82] == false);
2167 try expect(vec[83] == true);
2168 try expect(vec[84] == true);
2169 try expect(vec[85] == true);
2170 try expect(vec[86] == false);
2171 try expect(vec[87] == true);
2172 try expect(vec[88] == false);
2173 try expect(vec[89] == true);
2174 try expect(vec[90] == false);
2175 try expect(vec[91] == false);
2176 try expect(vec[92] == true);
2177 try expect(vec[93] == false);
2178 try expect(vec[94] == false);
2179 try expect(vec[95] == false);
2180 try expect(vec[96] == true);
2181 try expect(vec[97] == true);
2182 try expect(vec[98] == false);
2183 try expect(vec[99] == false);
2184 try expect(vec[100] == false);
2185 try expect(vec[101] == true);
2186 try expect(vec[102] == true);
2187 try expect(vec[103] == true);
2188 try expect(vec[104] == false);
2189 try expect(vec[105] == false);
2190 try expect(vec[106] == false);
2191 try expect(vec[107] == true);
2192 try expect(vec[108] == false);
2193 try expect(vec[109] == true);
2194 try expect(vec[110] == true);
2195 try expect(vec[111] == true);
2196 try expect(vec[112] == true);
2197 try expect(vec[113] == true);
2198 try expect(vec[114] == true);
2199 try expect(vec[115] == true);
2200 try expect(vec[116] == true);
2201 try expect(vec[117] == false);
2202 try expect(vec[118] == true);
2203 try expect(vec[119] == false);
2204 try expect(vec[120] == true);
2205 try expect(vec[121] == false);
2206 try expect(vec[122] == false);
2207 try expect(vec[123] == true);
2208 try expect(vec[124] == true);
2209 try expect(vec[125] == false);
2210 try expect(vec[126] == true);
2211 try expect(vec[127] == false);
2212 try expect(vec[128] == false);
2213 try expect(vec[129] == false);
2214 try expect(vec[130] == false);
2215 try expect(vec[131] == true);
2216 try expect(vec[132] == false);
2217 try expect(vec[133] == false);
2218 try expect(vec[134] == true);
2219 try expect(vec[135] == false);
2220 try expect(vec[136] == false);
2221 try expect(vec[137] == false);
2222 try expect(vec[138] == false);
2223 try expect(vec[139] == false);
2224 try expect(vec[140] == false);
2225 try expect(vec[141] == true);
2226 try expect(vec[142] == false);
2227 try expect(vec[143] == true);
2228 try expect(vec[144] == false);
2229 try expect(vec[145] == true);
2230 try expect(vec[146] == true);
2231 try expect(vec[147] == true);
2232 try expect(vec[148] == false);
2233 try expect(vec[149] == true);
2234 try expect(vec[150] == true);
2235 try expect(vec[151] == false);
2236 try expect(vec[152] == true);
2237 try expect(vec[153] == true);
2238 try expect(vec[154] == false);
2239 try expect(vec[155] == true);
2240 try expect(vec[156] == true);
2241 try expect(vec[157] == true);
2242 try expect(vec[158] == true);
2243 try expect(vec[159] == true);
2244 try expect(vec[160] == true);
2245 try expect(vec[161] == true);
2246 try expect(vec[162] == false);
2247 try expect(vec[163] == false);
2248 try expect(vec[164] == false);
2249 try expect(vec[165] == true);
2250 try expect(vec[166] == false);
2251 try expect(vec[167] == false);
2252 try expect(vec[168] == true);
2253 try expect(vec[169] == false);
2254 try expect(vec[170] == true);
2255 try expect(vec[171] == true);
2256 try expect(vec[172] == true);
2257 try expect(vec[173] == false);
2258 try expect(vec[174] == false);
2259 try expect(vec[175] == true);
2260 try expect(vec[176] == true);
2261 try expect(vec[177] == true);
2262 try expect(vec[178] == true);
2263 try expect(vec[179] == false);
2264 try expect(vec[180] == true);
2265 try expect(vec[181] == true);
2266 try expect(vec[182] == false);
2267 try expect(vec[183] == true);
2268 try expect(vec[184] == false);
2269 try expect(vec[185] == false);
2270 try expect(vec[186] == false);
2271 try expect(vec[187] == true);
2272 try expect(vec[188] == true);
2273 try expect(vec[189] == true);
2274 try expect(vec[190] == true);
2275 try expect(vec[191] == true);
2276 try expect(vec[192] == true);
2277 try expect(vec[193] == true);
2278 try expect(vec[194] == true);
2279 try expect(vec[195] == false);
2280 try expect(vec[196] == false);
2281 try expect(vec[197] == true);
2282 try expect(vec[198] == false);
2283 try expect(vec[199] == false);
2284 try expect(vec[200] == false);
2285 try expect(vec[201] == true);
2286 try expect(vec[202] == true);
2287 try expect(vec[203] == true);
2288 try expect(vec[204] == true);
2289 try expect(vec[205] == true);
2290 try expect(vec[206] == true);
2291 try expect(vec[207] == false);
2292 try expect(vec[208] == false);
2293 try expect(vec[209] == false);
2294 try expect(vec[210] == true);
2295 try expect(vec[211] == true);
2296 try expect(vec[212] == true);
2297 try expect(vec[213] == false);
2298 try expect(vec[214] == true);
2299 try expect(vec[215] == false);
2300 try expect(vec[216] == true);
2301 try expect(vec[217] == false);
2302 try expect(vec[218] == true);
2303 try expect(vec[219] == false);
2304 try expect(vec[220] == true);
2305 try expect(vec[221] == true);
2306 try expect(vec[222] == true);
2307 try expect(vec[223] == false);
2308 try expect(vec[224] == true);
2309 try expect(vec[225] == false);
2310 try expect(vec[226] == true);
2311 try expect(vec[227] == false);
2312 try expect(vec[228] == true);
2313 try expect(vec[229] == false);
2314 try expect(vec[230] == true);
2315 try expect(vec[231] == false);
2316 try expect(vec[232] == false);
2317 try expect(vec[233] == true);
2318 try expect(vec[234] == false);
2319 try expect(vec[235] == true);
2320 try expect(vec[236] == true);
2321 try expect(vec[237] == false);
2322 try expect(vec[238] == false);
2323 try expect(vec[239] == true);
2324 try expect(vec[240] == false);
2325 try expect(vec[241] == false);
2326 try expect(vec[242] == false);
2327 try expect(vec[243] == true);
2328 try expect(vec[244] == true);
2329 try expect(vec[245] == false);
2330 try expect(vec[246] == false);
2331 try expect(vec[247] == false);
2332 try expect(vec[248] == false);
2333 try expect(vec[249] == false);
2334 try expect(vec[250] == true);
2335 try expect(vec[251] == false);
2336 try expect(vec[252] == true);
2337 try expect(vec[253] == false);
2338 try expect(vec[254] == false);
2339 try expect(vec[255] == false);
2340 }
2341 {
2342 if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{
2343 true,
2344 true,
2345 true,
2346 true,
2347 true,
2348 false,
2349 false,
2350 true,
2351 true,
2352 true,
2353 true,
2354 false,
2355 true,
2356 true,
2357 false,
2358 false,
2359 false,
2360 true,
2361 true,
2362 true,
2363 true,
2364 true,
2365 false,
2366 false,
2367 true,
2368 true,
2369 false,
2370 false,
2371 false,
2372 false,
2373 false,
2374 true,
2375 true,
2376 false,
2377 true,
2378 true,
2379 true,
2380 true,
2381 true,
2382 true,
2383 false,
2384 true,
2385 true,
2386 false,
2387 false,
2388 false,
2389 true,
2390 true,
2391 false,
2392 true,
2393 false,
2394 true,
2395 true,
2396 false,
2397 true,
2398 false,
2399 false,
2400 true,
2401 true,
2402 false,
2403 true,
2404 true,
2405 false,
2406 true,
2407 false,
2408 true,
2409 true,
2410 true,
2411 true,
2412 true,
2413 true,
2414 true,
2415 true,
2416 true,
2417 false,
2418 true,
2419 false,
2420 true,
2421 false,
2422 false,
2423 false,
2424 true,
2425 false,
2426 true,
2427 true,
2428 false,
2429 true,
2430 true,
2431 true,
2432 false,
2433 true,
2434 true,
2435 false,
2436 true,
2437 false,
2438 true,
2439 true,
2440 false,
2441 false,
2442 false,
2443 true,
2444 true,
2445 false,
2446 true,
2447 false,
2448 false,
2449 true,
2450 false,
2451 false,
2452 true,
2453 false,
2454 false,
2455 false,
2456 false,
2457 false,
2458 true,
2459 true,
2460 false,
2461 false,
2462 false,
2463 false,
2464 true,
2465 false,
2466 false,
2467 true,
2468 true,
2469 false,
2470 true,
2471 false,
2472 true,
2473 true,
2474 false,
2475 true,
2476 false,
2477 false,
2478 false,
2479 false,
2480 true,
2481 true,
2482 false,
2483 false,
2484 false,
2485 true,
2486 true,
2487 false,
2488 false,
2489 true,
2490 true,
2491 true,
2492 true,
2493 true,
2494 true,
2495 true,
2496 false,
2497 true,
2498 false,
2499 false,
2500 true,
2501 false,
2502 true,
2503 false,
2504 true,
2505 true,
2506 true,
2507 true,
2508 true,
2509 true,
2510 true,
2511 true,
2512 false,
2513 true,
2514 true,
2515 false,
2516 true,
2517 true,
2518 false,
2519 false,
2520 false,
2521 true,
2522 false,
2523 false,
2524 true,
2525 true,
2526 true,
2527 true,
2528 true,
2529 true,
2530 true,
2531 true,
2532 true,
2533 false,
2534 true,
2535 true,
2536 false,
2537 false,
2538 true,
2539 true,
2540 false,
2541 true,
2542 true,
2543 false,
2544 true,
2545 true,
2546 false,
2547 true,
2548 true,
2549 true,
2550 true,
2551 false,
2552 true,
2553 false,
2554 true,
2555 true,
2556 false,
2557 true,
2558 false,
2559 true,
2560 false,
2561 true,
2562 false,
2563 false,
2564 true,
2565 false,
2566 false,
2567 false,
2568 true,
2569 true,
2570 false,
2571 false,
2572 false,
2573 true,
2574 false,
2575 true,
2576 false,
2577 false,
2578 false,
2579 true,
2580 true,
2581 false,
2582 false,
2583 false,
2584 false,
2585 false,
2586 true,
2587 true,
2588 false,
2589 true,
2590 false,
2591 false,
2592 true,
2593 false,
2594 false,
2595 false,
2596 true,
2597 false,
2598 false,
2599 false,
2600 false,
2601 true,
2602 true,
2603 true,
2604 true,
2605 false,
2606 true,
2607 false,
2608 false,
2609 false,
2610 true,
2611 false,
2612 false,
2613 true,
2614 true,
2615 false,
2616 false,
2617 false,
2618 false,
2619 false,
2620 true,
2621 false,
2622 true,
2623 true,
2624 true,
2625 true,
2626 true,
2627 false,
2628 false,
2629 false,
2630 false,
2631 false,
2632 false,
2633 false,
2634 false,
2635 false,
2636 true,
2637 true,
2638 true,
2639 true,
2640 true,
2641 true,
2642 false,
2643 true,
2644 false,
2645 true,
2646 true,
2647 true,
2648 false,
2649 false,
2650 true,
2651 true,
2652 true,
2653 false,
2654 true,
2655 true,
2656 true,
2657 false,
2658 true,
2659 true,
2660 true,
2661 false,
2662 true,
2663 true,
2664 false,
2665 false,
2666 true,
2667 false,
2668 false,
2669 false,
2670 false,
2671 true,
2672 false,
2673 true,
2674 true,
2675 true,
2676 true,
2677 false,
2678 false,
2679 true,
2680 false,
2681 true,
2682 false,
2683 false,
2684 false,
2685 true,
2686 false,
2687 true,
2688 false,
2689 false,
2690 true,
2691 true,
2692 true,
2693 true,
2694 false,
2695 false,
2696 false,
2697 true,
2698 true,
2699 false,
2700 true,
2701 false,
2702 false,
2703 true,
2704 false,
2705 true,
2706 false,
2707 true,
2708 true,
2709 false,
2710 false,
2711 true,
2712 true,
2713 true,
2714 true,
2715 false,
2716 false,
2717 true,
2718 false,
2719 true,
2720 true,
2721 false,
2722 true,
2723 true,
2724 false,
2725 true,
2726 true,
2727 true,
2728 false,
2729 true,
2730 true,
2731 true,
2732 false,
2733 false,
2734 true,
2735 false,
2736 true,
2737 true,
2738 true,
2739 false,
2740 false,
2741 false,
2742 false,
2743 false,
2744 true,
2745 false,
2746 false,
2747 false,
2748 false,
2749 true,
2750 false,
2751 false,
2752 true,
2753 true,
2754 false,
2755 false,
2756 false,
2757 false,
2758 true,
2759 true,
2760 true,
2761 true,
2762 true,
2763 false,
2764 false,
2765 false,
2766 true,
2767 false,
2768 false,
2769 false,
2770 false,
2771 true,
2772 false,
2773 true,
2774 false,
2775 true,
2776 true,
2777 true,
2778 true,
2779 false,
2780 false,
2781 false,
2782 false,
2783 false,
2784 true,
2785 true,
2786 true,
2787 true,
2788 true,
2789 true,
2790 true,
2791 true,
2792 true,
2793 false,
2794 false,
2795 true,
2796 false,
2797 true,
2798 false,
2799 false,
2800 true,
2801 false,
2802 false,
2803 true,
2804 true,
2805 true,
2806 true,
2807 true,
2808 true,
2809 false,
2810 true,
2811 false,
2812 false,
2813 false,
2814 true,
2815 true,
2816 false,
2817 true,
2818 true,
2819 false,
2820 false,
2821 true,
2822 true,
2823 false,
2824 false,
2825 true,
2826 true,
2827 false,
2828 true,
2829 false,
2830 true,
2831 true,
2832 true,
2833 true,
2834 true,
2835 true,
2836 true,
2837 true,
2838 true,
2839 false,
2840 true,
2841 true,
2842 true,
2843 false,
2844 false,
2845 true,
2846 false,
2847 false,
2848 false,
2849 true,
2850 true,
2851 false,
2852 true,
2853 false,
2854 true,
2855 });
2856
2857 const vec = c_ret_vector_512_bool();
2858 try expect(vec[0] == false);
2859 try expect(vec[1] == true);
2860 try expect(vec[2] == false);
2861 try expect(vec[3] == false);
2862 try expect(vec[4] == false);
2863 try expect(vec[5] == true);
2864 try expect(vec[6] == false);
2865 try expect(vec[7] == false);
2866 try expect(vec[8] == false);
2867 try expect(vec[9] == true);
2868 try expect(vec[10] == false);
2869 try expect(vec[11] == false);
2870 try expect(vec[12] == false);
2871 try expect(vec[13] == true);
2872 try expect(vec[14] == false);
2873 try expect(vec[15] == true);
2874 try expect(vec[16] == false);
2875 try expect(vec[17] == false);
2876 try expect(vec[18] == false);
2877 try expect(vec[19] == false);
2878 try expect(vec[20] == false);
2879 try expect(vec[21] == false);
2880 try expect(vec[22] == true);
2881 try expect(vec[23] == true);
2882 try expect(vec[24] == false);
2883 try expect(vec[25] == false);
2884 try expect(vec[26] == false);
2885 try expect(vec[27] == false);
2886 try expect(vec[28] == true);
2887 try expect(vec[29] == true);
2888 try expect(vec[30] == false);
2889 try expect(vec[31] == true);
2890 try expect(vec[32] == false);
2891 try expect(vec[33] == true);
2892 try expect(vec[34] == true);
2893 try expect(vec[35] == true);
2894 try expect(vec[36] == false);
2895 try expect(vec[37] == false);
2896 try expect(vec[38] == true);
2897 try expect(vec[39] == true);
2898 try expect(vec[40] == false);
2899 try expect(vec[41] == false);
2900 try expect(vec[42] == false);
2901 try expect(vec[43] == false);
2902 try expect(vec[44] == false);
2903 try expect(vec[45] == true);
2904 try expect(vec[46] == false);
2905 try expect(vec[47] == true);
2906 try expect(vec[48] == true);
2907 try expect(vec[49] == false);
2908 try expect(vec[50] == true);
2909 try expect(vec[51] == true);
2910 try expect(vec[52] == true);
2911 try expect(vec[53] == true);
2912 try expect(vec[54] == false);
2913 try expect(vec[55] == false);
2914 try expect(vec[56] == false);
2915 try expect(vec[57] == true);
2916 try expect(vec[58] == true);
2917 try expect(vec[59] == false);
2918 try expect(vec[60] == false);
2919 try expect(vec[61] == false);
2920 try expect(vec[62] == false);
2921 try expect(vec[63] == true);
2922 try expect(vec[64] == true);
2923 try expect(vec[65] == true);
2924 try expect(vec[66] == true);
2925 try expect(vec[67] == true);
2926 try expect(vec[68] == false);
2927 try expect(vec[69] == false);
2928 try expect(vec[70] == false);
2929 try expect(vec[71] == false);
2930 try expect(vec[72] == false);
2931 try expect(vec[73] == true);
2932 try expect(vec[74] == false);
2933 try expect(vec[75] == true);
2934 try expect(vec[76] == false);
2935 try expect(vec[77] == false);
2936 try expect(vec[78] == true);
2937 try expect(vec[79] == true);
2938 try expect(vec[80] == false);
2939 try expect(vec[81] == false);
2940 try expect(vec[82] == false);
2941 try expect(vec[83] == true);
2942 try expect(vec[84] == false);
2943 try expect(vec[85] == true);
2944 try expect(vec[86] == true);
2945 try expect(vec[87] == true);
2946 try expect(vec[88] == false);
2947 try expect(vec[89] == true);
2948 try expect(vec[90] == false);
2949 try expect(vec[91] == false);
2950 try expect(vec[92] == true);
2951 try expect(vec[93] == true);
2952 try expect(vec[94] == false);
2953 try expect(vec[95] == true);
2954 try expect(vec[96] == true);
2955 try expect(vec[97] == false);
2956 try expect(vec[98] == true);
2957 try expect(vec[99] == false);
2958 try expect(vec[100] == true);
2959 try expect(vec[101] == true);
2960 try expect(vec[102] == false);
2961 try expect(vec[103] == true);
2962 try expect(vec[104] == true);
2963 try expect(vec[105] == false);
2964 try expect(vec[106] == false);
2965 try expect(vec[107] == false);
2966 try expect(vec[108] == true);
2967 try expect(vec[109] == false);
2968 try expect(vec[110] == false);
2969 try expect(vec[111] == false);
2970 try expect(vec[112] == true);
2971 try expect(vec[113] == true);
2972 try expect(vec[114] == true);
2973 try expect(vec[115] == false);
2974 try expect(vec[116] == true);
2975 try expect(vec[117] == false);
2976 try expect(vec[118] == true);
2977 try expect(vec[119] == false);
2978 try expect(vec[120] == true);
2979 try expect(vec[121] == true);
2980 try expect(vec[122] == false);
2981 try expect(vec[123] == true);
2982 try expect(vec[124] == false);
2983 try expect(vec[125] == true);
2984 try expect(vec[126] == true);
2985 try expect(vec[127] == true);
2986 try expect(vec[128] == false);
2987 try expect(vec[129] == true);
2988 try expect(vec[130] == false);
2989 try expect(vec[131] == false);
2990 try expect(vec[132] == false);
2991 try expect(vec[133] == false);
2992 try expect(vec[134] == false);
2993 try expect(vec[135] == false);
2994 try expect(vec[136] == true);
2995 try expect(vec[137] == false);
2996 try expect(vec[138] == true);
2997 try expect(vec[139] == false);
2998 try expect(vec[140] == true);
2999 try expect(vec[141] == true);
3000 try expect(vec[142] == false);
3001 try expect(vec[143] == true);
3002 try expect(vec[144] == false);
3003 try expect(vec[145] == false);
3004 try expect(vec[146] == true);
3005 try expect(vec[147] == false);
3006 try expect(vec[148] == false);
3007 try expect(vec[149] == true);
3008 try expect(vec[150] == false);
3009 try expect(vec[151] == true);
3010 try expect(vec[152] == false);
3011 try expect(vec[153] == true);
3012 try expect(vec[154] == false);
3013 try expect(vec[155] == false);
3014 try expect(vec[156] == true);
3015 try expect(vec[157] == false);
3016 try expect(vec[158] == true);
3017 try expect(vec[159] == true);
3018 try expect(vec[160] == true);
3019 try expect(vec[161] == false);
3020 try expect(vec[162] == false);
3021 try expect(vec[163] == true);
3022 try expect(vec[164] == false);
3023 try expect(vec[165] == false);
3024 try expect(vec[166] == false);
3025 try expect(vec[167] == true);
3026 try expect(vec[168] == true);
3027 try expect(vec[169] == true);
3028 try expect(vec[170] == false);
3029 try expect(vec[171] == true);
3030 try expect(vec[172] == false);
3031 try expect(vec[173] == false);
3032 try expect(vec[174] == false);
3033 try expect(vec[175] == false);
3034 try expect(vec[176] == false);
3035 try expect(vec[177] == true);
3036 try expect(vec[178] == true);
3037 try expect(vec[179] == false);
3038 try expect(vec[180] == false);
3039 try expect(vec[181] == true);
3040 try expect(vec[182] == false);
3041 try expect(vec[183] == false);
3042 try expect(vec[184] == false);
3043 try expect(vec[185] == false);
3044 try expect(vec[186] == false);
3045 try expect(vec[187] == true);
3046 try expect(vec[188] == true);
3047 try expect(vec[189] == false);
3048 try expect(vec[190] == false);
3049 try expect(vec[191] == false);
3050 try expect(vec[192] == false);
3051 try expect(vec[193] == false);
3052 try expect(vec[194] == false);
3053 try expect(vec[195] == true);
3054 try expect(vec[196] == true);
3055 try expect(vec[197] == false);
3056 try expect(vec[198] == true);
3057 try expect(vec[199] == true);
3058 try expect(vec[200] == true);
3059 try expect(vec[201] == true);
3060 try expect(vec[202] == true);
3061 try expect(vec[203] == true);
3062 try expect(vec[204] == false);
3063 try expect(vec[205] == false);
3064 try expect(vec[206] == false);
3065 try expect(vec[207] == false);
3066 try expect(vec[208] == true);
3067 try expect(vec[209] == false);
3068 try expect(vec[210] == true);
3069 try expect(vec[211] == true);
3070 try expect(vec[212] == true);
3071 try expect(vec[213] == true);
3072 try expect(vec[214] == false);
3073 try expect(vec[215] == false);
3074 try expect(vec[216] == false);
3075 try expect(vec[217] == true);
3076 try expect(vec[218] == true);
3077 try expect(vec[219] == false);
3078 try expect(vec[220] == true);
3079 try expect(vec[221] == true);
3080 try expect(vec[222] == false);
3081 try expect(vec[223] == false);
3082 try expect(vec[224] == false);
3083 try expect(vec[225] == true);
3084 try expect(vec[226] == true);
3085 try expect(vec[227] == true);
3086 try expect(vec[228] == true);
3087 try expect(vec[229] == false);
3088 try expect(vec[230] == true);
3089 try expect(vec[231] == false);
3090 try expect(vec[232] == true);
3091 try expect(vec[233] == true);
3092 try expect(vec[234] == true);
3093 try expect(vec[235] == true);
3094 try expect(vec[236] == false);
3095 try expect(vec[237] == true);
3096 try expect(vec[238] == false);
3097 try expect(vec[239] == true);
3098 try expect(vec[240] == false);
3099 try expect(vec[241] == true);
3100 try expect(vec[242] == false);
3101 try expect(vec[243] == false);
3102 try expect(vec[244] == false);
3103 try expect(vec[245] == true);
3104 try expect(vec[246] == true);
3105 try expect(vec[247] == false);
3106 try expect(vec[248] == true);
3107 try expect(vec[249] == false);
3108 try expect(vec[250] == false);
3109 try expect(vec[251] == false);
3110 try expect(vec[252] == true);
3111 try expect(vec[253] == true);
3112 try expect(vec[254] == true);
3113 try expect(vec[255] == true);
3114 try expect(vec[256] == true);
3115 try expect(vec[257] == false);
3116 try expect(vec[258] == true);
3117 try expect(vec[259] == true);
3118 try expect(vec[260] == true);
3119 try expect(vec[261] == true);
3120 try expect(vec[262] == false);
3121 try expect(vec[263] == true);
3122 try expect(vec[264] == false);
3123 try expect(vec[265] == false);
3124 try expect(vec[266] == true);
3125 try expect(vec[267] == false);
3126 try expect(vec[268] == true);
3127 try expect(vec[269] == false);
3128 try expect(vec[270] == false);
3129 try expect(vec[271] == true);
3130 try expect(vec[272] == true);
3131 try expect(vec[273] == false);
3132 try expect(vec[274] == true);
3133 try expect(vec[275] == false);
3134 try expect(vec[276] == false);
3135 try expect(vec[277] == true);
3136 try expect(vec[278] == false);
3137 try expect(vec[279] == false);
3138 try expect(vec[280] == true);
3139 try expect(vec[281] == true);
3140 try expect(vec[282] == true);
3141 try expect(vec[283] == false);
3142 try expect(vec[284] == false);
3143 try expect(vec[285] == true);
3144 try expect(vec[286] == true);
3145 try expect(vec[287] == true);
3146 try expect(vec[288] == false);
3147 try expect(vec[289] == false);
3148 try expect(vec[290] == false);
3149 try expect(vec[291] == false);
3150 try expect(vec[292] == false);
3151 try expect(vec[293] == false);
3152 try expect(vec[294] == true);
3153 try expect(vec[295] == false);
3154 try expect(vec[296] == true);
3155 try expect(vec[297] == false);
3156 try expect(vec[298] == true);
3157 try expect(vec[299] == true);
3158 try expect(vec[300] == false);
3159 try expect(vec[301] == false);
3160 try expect(vec[302] == false);
3161 try expect(vec[303] == false);
3162 try expect(vec[304] == true);
3163 try expect(vec[305] == true);
3164 try expect(vec[306] == true);
3165 try expect(vec[307] == true);
3166 try expect(vec[308] == true);
3167 try expect(vec[309] == false);
3168 try expect(vec[310] == true);
3169 try expect(vec[311] == true);
3170 try expect(vec[312] == true);
3171 try expect(vec[313] == true);
3172 try expect(vec[314] == true);
3173 try expect(vec[315] == false);
3174 try expect(vec[316] == true);
3175 try expect(vec[317] == true);
3176 try expect(vec[318] == true);
3177 try expect(vec[319] == false);
3178 try expect(vec[320] == true);
3179 try expect(vec[321] == false);
3180 try expect(vec[322] == true);
3181 try expect(vec[323] == true);
3182 try expect(vec[324] == true);
3183 try expect(vec[325] == false);
3184 try expect(vec[326] == false);
3185 try expect(vec[327] == true);
3186 try expect(vec[328] == true);
3187 try expect(vec[329] == true);
3188 try expect(vec[330] == false);
3189 try expect(vec[331] == false);
3190 try expect(vec[332] == true);
3191 try expect(vec[333] == true);
3192 try expect(vec[334] == false);
3193 try expect(vec[335] == true);
3194 try expect(vec[336] == true);
3195 try expect(vec[337] == true);
3196 try expect(vec[338] == true);
3197 try expect(vec[339] == true);
3198 try expect(vec[340] == true);
3199 try expect(vec[341] == false);
3200 try expect(vec[342] == true);
3201 try expect(vec[343] == false);
3202 try expect(vec[344] == true);
3203 try expect(vec[345] == false);
3204 try expect(vec[346] == false);
3205 try expect(vec[347] == false);
3206 try expect(vec[348] == false);
3207 try expect(vec[349] == true);
3208 try expect(vec[350] == true);
3209 try expect(vec[351] == true);
3210 try expect(vec[352] == true);
3211 try expect(vec[353] == false);
3212 try expect(vec[354] == true);
3213 try expect(vec[355] == false);
3214 try expect(vec[356] == true);
3215 try expect(vec[357] == true);
3216 try expect(vec[358] == false);
3217 try expect(vec[359] == true);
3218 try expect(vec[360] == false);
3219 try expect(vec[361] == false);
3220 try expect(vec[362] == true);
3221 try expect(vec[363] == false);
3222 try expect(vec[364] == false);
3223 try expect(vec[365] == false);
3224 try expect(vec[366] == false);
3225 try expect(vec[367] == false);
3226 try expect(vec[368] == false);
3227 try expect(vec[369] == false);
3228 try expect(vec[370] == true);
3229 try expect(vec[371] == false);
3230 try expect(vec[372] == true);
3231 try expect(vec[373] == true);
3232 try expect(vec[374] == false);
3233 try expect(vec[375] == false);
3234 try expect(vec[376] == true);
3235 try expect(vec[377] == false);
3236 try expect(vec[378] == false);
3237 try expect(vec[379] == true);
3238 try expect(vec[380] == false);
3239 try expect(vec[381] == false);
3240 try expect(vec[382] == true);
3241 try expect(vec[383] == false);
3242 try expect(vec[384] == false);
3243 try expect(vec[385] == false);
3244 try expect(vec[386] == false);
3245 try expect(vec[387] == true);
3246 try expect(vec[388] == true);
3247 try expect(vec[389] == true);
3248 try expect(vec[390] == true);
3249 try expect(vec[391] == true);
3250 try expect(vec[392] == true);
3251 try expect(vec[393] == true);
3252 try expect(vec[394] == false);
3253 try expect(vec[395] == true);
3254 try expect(vec[396] == true);
3255 try expect(vec[397] == false);
3256 try expect(vec[398] == false);
3257 try expect(vec[399] == false);
3258 try expect(vec[400] == true);
3259 try expect(vec[401] == false);
3260 try expect(vec[402] == true);
3261 try expect(vec[403] == true);
3262 try expect(vec[404] == false);
3263 try expect(vec[405] == true);
3264 try expect(vec[406] == true);
3265 try expect(vec[407] == true);
3266 try expect(vec[408] == true);
3267 try expect(vec[409] == false);
3268 try expect(vec[410] == false);
3269 try expect(vec[411] == false);
3270 try expect(vec[412] == true);
3271 try expect(vec[413] == true);
3272 try expect(vec[414] == false);
3273 try expect(vec[415] == true);
3274 try expect(vec[416] == false);
3275 try expect(vec[417] == true);
3276 try expect(vec[418] == false);
3277 try expect(vec[419] == false);
3278 try expect(vec[420] == false);
3279 try expect(vec[421] == false);
3280 try expect(vec[422] == true);
3281 try expect(vec[423] == true);
3282 try expect(vec[424] == true);
3283 try expect(vec[425] == false);
3284 try expect(vec[426] == true);
3285 try expect(vec[427] == false);
3286 try expect(vec[428] == false);
3287 try expect(vec[429] == false);
3288 try expect(vec[430] == true);
3289 try expect(vec[431] == true);
3290 try expect(vec[432] == false);
3291 try expect(vec[433] == true);
3292 try expect(vec[434] == false);
3293 try expect(vec[435] == false);
3294 try expect(vec[436] == true);
3295 try expect(vec[437] == true);
3296 try expect(vec[438] == true);
3297 try expect(vec[439] == true);
3298 try expect(vec[440] == true);
3299 try expect(vec[441] == true);
3300 try expect(vec[442] == false);
3301 try expect(vec[443] == false);
3302 try expect(vec[444] == false);
3303 try expect(vec[445] == true);
3304 try expect(vec[446] == true);
3305 try expect(vec[447] == true);
3306 try expect(vec[448] == false);
3307 try expect(vec[449] == false);
3308 try expect(vec[450] == false);
3309 try expect(vec[451] == false);
3310 try expect(vec[452] == false);
3311 try expect(vec[453] == false);
3312 try expect(vec[454] == false);
3313 try expect(vec[455] == false);
3314 try expect(vec[456] == false);
3315 try expect(vec[457] == false);
3316 try expect(vec[458] == false);
3317 try expect(vec[459] == true);
3318 try expect(vec[460] == false);
3319 try expect(vec[461] == false);
3320 try expect(vec[462] == false);
3321 try expect(vec[463] == true);
3322 try expect(vec[464] == false);
3323 try expect(vec[465] == false);
3324 try expect(vec[466] == false);
3325 try expect(vec[467] == false);
3326 try expect(vec[468] == true);
3327 try expect(vec[469] == true);
3328 try expect(vec[470] == true);
3329 try expect(vec[471] == true);
3330 try expect(vec[472] == true);
3331 try expect(vec[473] == false);
3332 try expect(vec[474] == false);
3333 try expect(vec[475] == true);
3334 try expect(vec[476] == true);
3335 try expect(vec[477] == true);
3336 try expect(vec[478] == false);
3337 try expect(vec[479] == true);
3338 try expect(vec[480] == true);
3339 try expect(vec[481] == true);
3340 try expect(vec[482] == false);
3341 try expect(vec[483] == true);
3342 try expect(vec[484] == false);
3343 try expect(vec[485] == true);
3344 try expect(vec[486] == false);
3345 try expect(vec[487] == true);
3346 try expect(vec[488] == false);
3347 try expect(vec[489] == true);
3348 try expect(vec[490] == true);
3349 try expect(vec[491] == true);
3350 try expect(vec[492] == true);
3351 try expect(vec[493] == false);
3352 try expect(vec[494] == true);
3353 try expect(vec[495] == true);
3354 try expect(vec[496] == false);
3355 try expect(vec[497] == true);
3356 try expect(vec[498] == false);
3357 try expect(vec[499] == false);
3358 try expect(vec[500] == false);
3359 try expect(vec[501] == false);
3360 try expect(vec[502] == false);
3361 try expect(vec[503] == false);
3362 try expect(vec[504] == false);
3363 try expect(vec[505] == false);
3364 try expect(vec[506] == false);
3365 try expect(vec[507] == true);
3366 try expect(vec[508] == true);
3367 try expect(vec[509] == false);
3368 try expect(vec[510] == true);
3369 try expect(vec[511] == false);
3370 }
3371}
3372
3373comptime {
3374 skip: {
3375 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
3376
3377 _ = struct {
3378 export fn zig_vector_2_bool(vec: Vector2Bool) void {
3379 expect(vec[0] == false) catch @panic("test failure");
3380 expect(vec[1] == true) catch @panic("test failure");
3381 }
3382
3383 export fn zig_vector_4_bool(vec: Vector4Bool) void {
3384 expect(vec[0] == false) catch @panic("test failure");
3385 expect(vec[1] == false) catch @panic("test failure");
3386 expect(vec[2] == false) catch @panic("test failure");
3387 expect(vec[3] == false) catch @panic("test failure");
3388 }
3389
3390 export fn zig_vector_8_bool(vec: Vector8Bool) void {
3391 expect(vec[0] == true) catch @panic("test failure");
3392 expect(vec[1] == true) catch @panic("test failure");
3393 expect(vec[2] == false) catch @panic("test failure");
3394 expect(vec[3] == true) catch @panic("test failure");
3395 expect(vec[4] == false) catch @panic("test failure");
3396 expect(vec[5] == true) catch @panic("test failure");
3397 expect(vec[6] == true) catch @panic("test failure");
3398 expect(vec[7] == false) catch @panic("test failure");
3399 }
3400
3401 export fn zig_vector_16_bool(vec: Vector16Bool) void {
3402 expect(vec[0] == true) catch @panic("test failure");
3403 expect(vec[1] == false) catch @panic("test failure");
3404 expect(vec[2] == true) catch @panic("test failure");
3405 expect(vec[3] == true) catch @panic("test failure");
3406 expect(vec[4] == true) catch @panic("test failure");
3407 expect(vec[5] == false) catch @panic("test failure");
3408 expect(vec[6] == false) catch @panic("test failure");
3409 expect(vec[7] == false) catch @panic("test failure");
3410 expect(vec[8] == true) catch @panic("test failure");
3411 expect(vec[9] == true) catch @panic("test failure");
3412 expect(vec[10] == true) catch @panic("test failure");
3413 expect(vec[11] == true) catch @panic("test failure");
3414 expect(vec[12] == false) catch @panic("test failure");
3415 expect(vec[13] == false) catch @panic("test failure");
3416 expect(vec[14] == false) catch @panic("test failure");
3417 expect(vec[15] == true) catch @panic("test failure");
3418 }
3419
3420 export fn zig_vector_32_bool(vec: Vector32Bool) void {
3421 expect(vec[0] == false) catch @panic("test failure");
3422 expect(vec[1] == false) catch @panic("test failure");
3423 expect(vec[2] == false) catch @panic("test failure");
3424 expect(vec[3] == true) catch @panic("test failure");
3425 expect(vec[4] == true) catch @panic("test failure");
3426 expect(vec[5] == false) catch @panic("test failure");
3427 expect(vec[6] == false) catch @panic("test failure");
3428 expect(vec[7] == true) catch @panic("test failure");
3429 expect(vec[8] == false) catch @panic("test failure");
3430 expect(vec[9] == true) catch @panic("test failure");
3431 expect(vec[10] == true) catch @panic("test failure");
3432 expect(vec[11] == true) catch @panic("test failure");
3433 expect(vec[12] == false) catch @panic("test failure");
3434 expect(vec[13] == false) catch @panic("test failure");
3435 expect(vec[14] == true) catch @panic("test failure");
3436 expect(vec[15] == true) catch @panic("test failure");
3437 expect(vec[16] == true) catch @panic("test failure");
3438 expect(vec[17] == true) catch @panic("test failure");
3439 expect(vec[18] == true) catch @panic("test failure");
3440 expect(vec[19] == false) catch @panic("test failure");
3441 expect(vec[20] == true) catch @panic("test failure");
3442 expect(vec[21] == true) catch @panic("test failure");
3443 expect(vec[22] == true) catch @panic("test failure");
3444 expect(vec[23] == false) catch @panic("test failure");
3445 expect(vec[24] == false) catch @panic("test failure");
3446 expect(vec[25] == true) catch @panic("test failure");
3447 expect(vec[26] == true) catch @panic("test failure");
3448 expect(vec[27] == false) catch @panic("test failure");
3449 expect(vec[28] == true) catch @panic("test failure");
3450 expect(vec[29] == true) catch @panic("test failure");
3451 expect(vec[30] == false) catch @panic("test failure");
3452 expect(vec[31] == true) catch @panic("test failure");
3453 }
3454
3455 export fn zig_vector_64_bool(vec: Vector64Bool) void {
3456 expect(vec[0] == true) catch @panic("test failure");
3457 expect(vec[1] == true) catch @panic("test failure");
3458 expect(vec[2] == false) catch @panic("test failure");
3459 expect(vec[3] == true) catch @panic("test failure");
3460 expect(vec[4] == false) catch @panic("test failure");
3461 expect(vec[5] == true) catch @panic("test failure");
3462 expect(vec[6] == false) catch @panic("test failure");
3463 expect(vec[7] == false) catch @panic("test failure");
3464 expect(vec[8] == true) catch @panic("test failure");
3465 expect(vec[9] == true) catch @panic("test failure");
3466 expect(vec[10] == true) catch @panic("test failure");
3467 expect(vec[11] == true) catch @panic("test failure");
3468 expect(vec[12] == true) catch @panic("test failure");
3469 expect(vec[13] == true) catch @panic("test failure");
3470 expect(vec[14] == true) catch @panic("test failure");
3471 expect(vec[15] == false) catch @panic("test failure");
3472 expect(vec[16] == false) catch @panic("test failure");
3473 expect(vec[17] == true) catch @panic("test failure");
3474 expect(vec[18] == true) catch @panic("test failure");
3475 expect(vec[19] == false) catch @panic("test failure");
3476 expect(vec[20] == true) catch @panic("test failure");
3477 expect(vec[21] == true) catch @panic("test failure");
3478 expect(vec[22] == true) catch @panic("test failure");
3479 expect(vec[23] == true) catch @panic("test failure");
3480 expect(vec[24] == false) catch @panic("test failure");
3481 expect(vec[25] == false) catch @panic("test failure");
3482 expect(vec[26] == true) catch @panic("test failure");
3483 expect(vec[27] == false) catch @panic("test failure");
3484 expect(vec[28] == false) catch @panic("test failure");
3485 expect(vec[29] == true) catch @panic("test failure");
3486 expect(vec[30] == false) catch @panic("test failure");
3487 expect(vec[31] == true) catch @panic("test failure");
3488 expect(vec[32] == false) catch @panic("test failure");
3489 expect(vec[33] == true) catch @panic("test failure");
3490 expect(vec[34] == true) catch @panic("test failure");
3491 expect(vec[35] == false) catch @panic("test failure");
3492 expect(vec[36] == true) catch @panic("test failure");
3493 expect(vec[37] == true) catch @panic("test failure");
3494 expect(vec[38] == false) catch @panic("test failure");
3495 expect(vec[39] == false) catch @panic("test failure");
3496 expect(vec[40] == true) catch @panic("test failure");
3497 expect(vec[41] == true) catch @panic("test failure");
3498 expect(vec[42] == true) catch @panic("test failure");
3499 expect(vec[43] == true) catch @panic("test failure");
3500 expect(vec[44] == true) catch @panic("test failure");
3501 expect(vec[45] == false) catch @panic("test failure");
3502 expect(vec[46] == true) catch @panic("test failure");
3503 expect(vec[47] == false) catch @panic("test failure");
3504 expect(vec[48] == false) catch @panic("test failure");
3505 expect(vec[49] == false) catch @panic("test failure");
3506 expect(vec[50] == false) catch @panic("test failure");
3507 expect(vec[51] == false) catch @panic("test failure");
3508 expect(vec[52] == true) catch @panic("test failure");
3509 expect(vec[53] == false) catch @panic("test failure");
3510 expect(vec[54] == false) catch @panic("test failure");
3511 expect(vec[55] == true) catch @panic("test failure");
3512 expect(vec[56] == true) catch @panic("test failure");
3513 expect(vec[57] == false) catch @panic("test failure");
3514 expect(vec[58] == false) catch @panic("test failure");
3515 expect(vec[59] == false) catch @panic("test failure");
3516 expect(vec[60] == true) catch @panic("test failure");
3517 expect(vec[61] == true) catch @panic("test failure");
3518 expect(vec[62] == true) catch @panic("test failure");
3519 expect(vec[63] == true) catch @panic("test failure");
3520 }
3521
3522 export fn zig_vector_128_bool(vec: Vector128Bool) void {
3523 expect(vec[0] == true) catch @panic("test failure");
3524 expect(vec[1] == true) catch @panic("test failure");
3525 expect(vec[2] == false) catch @panic("test failure");
3526 expect(vec[3] == true) catch @panic("test failure");
3527 expect(vec[4] == true) catch @panic("test failure");
3528 expect(vec[5] == false) catch @panic("test failure");
3529 expect(vec[6] == false) catch @panic("test failure");
3530 expect(vec[7] == true) catch @panic("test failure");
3531 expect(vec[8] == true) catch @panic("test failure");
3532 expect(vec[9] == true) catch @panic("test failure");
3533 expect(vec[10] == true) catch @panic("test failure");
3534 expect(vec[11] == true) catch @panic("test failure");
3535 expect(vec[12] == false) catch @panic("test failure");
3536 expect(vec[13] == false) catch @panic("test failure");
3537 expect(vec[14] == false) catch @panic("test failure");
3538 expect(vec[15] == true) catch @panic("test failure");
3539 expect(vec[16] == false) catch @panic("test failure");
3540 expect(vec[17] == true) catch @panic("test failure");
3541 expect(vec[18] == false) catch @panic("test failure");
3542 expect(vec[19] == false) catch @panic("test failure");
3543 expect(vec[20] == true) catch @panic("test failure");
3544 expect(vec[21] == false) catch @panic("test failure");
3545 expect(vec[22] == true) catch @panic("test failure");
3546 expect(vec[23] == false) catch @panic("test failure");
3547 expect(vec[24] == false) catch @panic("test failure");
3548 expect(vec[25] == false) catch @panic("test failure");
3549 expect(vec[26] == true) catch @panic("test failure");
3550 expect(vec[27] == false) catch @panic("test failure");
3551 expect(vec[28] == true) catch @panic("test failure");
3552 expect(vec[29] == true) catch @panic("test failure");
3553 expect(vec[30] == false) catch @panic("test failure");
3554 expect(vec[31] == true) catch @panic("test failure");
3555 expect(vec[32] == false) catch @panic("test failure");
3556 expect(vec[33] == true) catch @panic("test failure");
3557 expect(vec[34] == true) catch @panic("test failure");
3558 expect(vec[35] == false) catch @panic("test failure");
3559 expect(vec[36] == false) catch @panic("test failure");
3560 expect(vec[37] == false) catch @panic("test failure");
3561 expect(vec[38] == false) catch @panic("test failure");
3562 expect(vec[39] == true) catch @panic("test failure");
3563 expect(vec[40] == true) catch @panic("test failure");
3564 expect(vec[41] == false) catch @panic("test failure");
3565 expect(vec[42] == true) catch @panic("test failure");
3566 expect(vec[43] == false) catch @panic("test failure");
3567 expect(vec[44] == false) catch @panic("test failure");
3568 expect(vec[45] == true) catch @panic("test failure");
3569 expect(vec[46] == false) catch @panic("test failure");
3570 expect(vec[47] == false) catch @panic("test failure");
3571 expect(vec[48] == true) catch @panic("test failure");
3572 expect(vec[49] == true) catch @panic("test failure");
3573 expect(vec[50] == false) catch @panic("test failure");
3574 expect(vec[51] == false) catch @panic("test failure");
3575 expect(vec[52] == true) catch @panic("test failure");
3576 expect(vec[53] == false) catch @panic("test failure");
3577 expect(vec[54] == false) catch @panic("test failure");
3578 expect(vec[55] == true) catch @panic("test failure");
3579 expect(vec[56] == true) catch @panic("test failure");
3580 expect(vec[57] == true) catch @panic("test failure");
3581 expect(vec[58] == true) catch @panic("test failure");
3582 expect(vec[59] == true) catch @panic("test failure");
3583 expect(vec[60] == true) catch @panic("test failure");
3584 expect(vec[61] == true) catch @panic("test failure");
3585 expect(vec[62] == true) catch @panic("test failure");
3586 expect(vec[63] == false) catch @panic("test failure");
3587 expect(vec[64] == false) catch @panic("test failure");
3588 expect(vec[65] == true) catch @panic("test failure");
3589 expect(vec[66] == false) catch @panic("test failure");
3590 expect(vec[67] == true) catch @panic("test failure");
3591 expect(vec[68] == true) catch @panic("test failure");
3592 expect(vec[69] == true) catch @panic("test failure");
3593 expect(vec[70] == true) catch @panic("test failure");
3594 expect(vec[71] == false) catch @panic("test failure");
3595 expect(vec[72] == false) catch @panic("test failure");
3596 expect(vec[73] == false) catch @panic("test failure");
3597 expect(vec[74] == true) catch @panic("test failure");
3598 expect(vec[75] == true) catch @panic("test failure");
3599 expect(vec[76] == false) catch @panic("test failure");
3600 expect(vec[77] == true) catch @panic("test failure");
3601 expect(vec[78] == true) catch @panic("test failure");
3602 expect(vec[79] == true) catch @panic("test failure");
3603 expect(vec[80] == true) catch @panic("test failure");
3604 expect(vec[81] == false) catch @panic("test failure");
3605 expect(vec[82] == true) catch @panic("test failure");
3606 expect(vec[83] == true) catch @panic("test failure");
3607 expect(vec[84] == true) catch @panic("test failure");
3608 expect(vec[85] == true) catch @panic("test failure");
3609 expect(vec[86] == true) catch @panic("test failure");
3610 expect(vec[87] == true) catch @panic("test failure");
3611 expect(vec[88] == false) catch @panic("test failure");
3612 expect(vec[89] == true) catch @panic("test failure");
3613 expect(vec[90] == true) catch @panic("test failure");
3614 expect(vec[91] == true) catch @panic("test failure");
3615 expect(vec[92] == true) catch @panic("test failure");
3616 expect(vec[93] == true) catch @panic("test failure");
3617 expect(vec[94] == true) catch @panic("test failure");
3618 expect(vec[95] == false) catch @panic("test failure");
3619 expect(vec[96] == false) catch @panic("test failure");
3620 expect(vec[97] == false) catch @panic("test failure");
3621 expect(vec[98] == true) catch @panic("test failure");
3622 expect(vec[99] == true) catch @panic("test failure");
3623 expect(vec[100] == true) catch @panic("test failure");
3624 expect(vec[101] == true) catch @panic("test failure");
3625 expect(vec[102] == true) catch @panic("test failure");
3626 expect(vec[103] == true) catch @panic("test failure");
3627 expect(vec[104] == true) catch @panic("test failure");
3628 expect(vec[105] == false) catch @panic("test failure");
3629 expect(vec[106] == false) catch @panic("test failure");
3630 expect(vec[107] == false) catch @panic("test failure");
3631 expect(vec[108] == false) catch @panic("test failure");
3632 expect(vec[109] == false) catch @panic("test failure");
3633 expect(vec[110] == true) catch @panic("test failure");
3634 expect(vec[111] == true) catch @panic("test failure");
3635 expect(vec[112] == true) catch @panic("test failure");
3636 expect(vec[113] == false) catch @panic("test failure");
3637 expect(vec[114] == false) catch @panic("test failure");
3638 expect(vec[115] == false) catch @panic("test failure");
3639 expect(vec[116] == false) catch @panic("test failure");
3640 expect(vec[117] == false) catch @panic("test failure");
3641 expect(vec[118] == true) catch @panic("test failure");
3642 expect(vec[119] == false) catch @panic("test failure");
3643 expect(vec[120] == false) catch @panic("test failure");
3644 expect(vec[121] == false) catch @panic("test failure");
3645 expect(vec[122] == false) catch @panic("test failure");
3646 expect(vec[123] == true) catch @panic("test failure");
3647 expect(vec[124] == true) catch @panic("test failure");
3648 expect(vec[125] == false) catch @panic("test failure");
3649 expect(vec[126] == true) catch @panic("test failure");
3650 expect(vec[127] == false) catch @panic("test failure");
3651 }
3652
3653 export fn zig_vector_256_bool(vec: Vector256Bool) void {
3654 expect(vec[0] == false) catch @panic("test failure");
3655 expect(vec[1] == false) catch @panic("test failure");
3656 expect(vec[2] == false) catch @panic("test failure");
3657 expect(vec[3] == false) catch @panic("test failure");
3658 expect(vec[4] == true) catch @panic("test failure");
3659 expect(vec[5] == true) catch @panic("test failure");
3660 expect(vec[6] == false) catch @panic("test failure");
3661 expect(vec[7] == false) catch @panic("test failure");
3662 expect(vec[8] == false) catch @panic("test failure");
3663 expect(vec[9] == true) catch @panic("test failure");
3664 expect(vec[10] == true) catch @panic("test failure");
3665 expect(vec[11] == false) catch @panic("test failure");
3666 expect(vec[12] == true) catch @panic("test failure");
3667 expect(vec[13] == false) catch @panic("test failure");
3668 expect(vec[14] == false) catch @panic("test failure");
3669 expect(vec[15] == false) catch @panic("test failure");
3670 expect(vec[16] == false) catch @panic("test failure");
3671 expect(vec[17] == true) catch @panic("test failure");
3672 expect(vec[18] == true) catch @panic("test failure");
3673 expect(vec[19] == true) catch @panic("test failure");
3674 expect(vec[20] == false) catch @panic("test failure");
3675 expect(vec[21] == true) catch @panic("test failure");
3676 expect(vec[22] == true) catch @panic("test failure");
3677 expect(vec[23] == false) catch @panic("test failure");
3678 expect(vec[24] == true) catch @panic("test failure");
3679 expect(vec[25] == false) catch @panic("test failure");
3680 expect(vec[26] == false) catch @panic("test failure");
3681 expect(vec[27] == true) catch @panic("test failure");
3682 expect(vec[28] == true) catch @panic("test failure");
3683 expect(vec[29] == true) catch @panic("test failure");
3684 expect(vec[30] == false) catch @panic("test failure");
3685 expect(vec[31] == true) catch @panic("test failure");
3686 expect(vec[32] == false) catch @panic("test failure");
3687 expect(vec[33] == true) catch @panic("test failure");
3688 expect(vec[34] == false) catch @panic("test failure");
3689 expect(vec[35] == false) catch @panic("test failure");
3690 expect(vec[36] == false) catch @panic("test failure");
3691 expect(vec[37] == true) catch @panic("test failure");
3692 expect(vec[38] == false) catch @panic("test failure");
3693 expect(vec[39] == false) catch @panic("test failure");
3694 expect(vec[40] == true) catch @panic("test failure");
3695 expect(vec[41] == true) catch @panic("test failure");
3696 expect(vec[42] == false) catch @panic("test failure");
3697 expect(vec[43] == true) catch @panic("test failure");
3698 expect(vec[44] == true) catch @panic("test failure");
3699 expect(vec[45] == false) catch @panic("test failure");
3700 expect(vec[46] == true) catch @panic("test failure");
3701 expect(vec[47] == false) catch @panic("test failure");
3702 expect(vec[48] == true) catch @panic("test failure");
3703 expect(vec[49] == false) catch @panic("test failure");
3704 expect(vec[50] == true) catch @panic("test failure");
3705 expect(vec[51] == false) catch @panic("test failure");
3706 expect(vec[52] == true) catch @panic("test failure");
3707 expect(vec[53] == true) catch @panic("test failure");
3708 expect(vec[54] == true) catch @panic("test failure");
3709 expect(vec[55] == false) catch @panic("test failure");
3710 expect(vec[56] == false) catch @panic("test failure");
3711 expect(vec[57] == true) catch @panic("test failure");
3712 expect(vec[58] == true) catch @panic("test failure");
3713 expect(vec[59] == false) catch @panic("test failure");
3714 expect(vec[60] == false) catch @panic("test failure");
3715 expect(vec[61] == true) catch @panic("test failure");
3716 expect(vec[62] == true) catch @panic("test failure");
3717 expect(vec[63] == false) catch @panic("test failure");
3718 expect(vec[64] == false) catch @panic("test failure");
3719 expect(vec[65] == false) catch @panic("test failure");
3720 expect(vec[66] == true) catch @panic("test failure");
3721 expect(vec[67] == true) catch @panic("test failure");
3722 expect(vec[68] == false) catch @panic("test failure");
3723 expect(vec[69] == true) catch @panic("test failure");
3724 expect(vec[70] == false) catch @panic("test failure");
3725 expect(vec[71] == true) catch @panic("test failure");
3726 expect(vec[72] == false) catch @panic("test failure");
3727 expect(vec[73] == true) catch @panic("test failure");
3728 expect(vec[74] == false) catch @panic("test failure");
3729 expect(vec[75] == false) catch @panic("test failure");
3730 expect(vec[76] == true) catch @panic("test failure");
3731 expect(vec[77] == false) catch @panic("test failure");
3732 expect(vec[78] == false) catch @panic("test failure");
3733 expect(vec[79] == false) catch @panic("test failure");
3734 expect(vec[80] == false) catch @panic("test failure");
3735 expect(vec[81] == false) catch @panic("test failure");
3736 expect(vec[82] == true) catch @panic("test failure");
3737 expect(vec[83] == false) catch @panic("test failure");
3738 expect(vec[84] == false) catch @panic("test failure");
3739 expect(vec[85] == false) catch @panic("test failure");
3740 expect(vec[86] == true) catch @panic("test failure");
3741 expect(vec[87] == true) catch @panic("test failure");
3742 expect(vec[88] == true) catch @panic("test failure");
3743 expect(vec[89] == false) catch @panic("test failure");
3744 expect(vec[90] == true) catch @panic("test failure");
3745 expect(vec[91] == false) catch @panic("test failure");
3746 expect(vec[92] == true) catch @panic("test failure");
3747 expect(vec[93] == false) catch @panic("test failure");
3748 expect(vec[94] == true) catch @panic("test failure");
3749 expect(vec[95] == true) catch @panic("test failure");
3750 expect(vec[96] == true) catch @panic("test failure");
3751 expect(vec[97] == true) catch @panic("test failure");
3752 expect(vec[98] == false) catch @panic("test failure");
3753 expect(vec[99] == true) catch @panic("test failure");
3754 expect(vec[100] == false) catch @panic("test failure");
3755 expect(vec[101] == true) catch @panic("test failure");
3756 expect(vec[102] == true) catch @panic("test failure");
3757 expect(vec[103] == false) catch @panic("test failure");
3758 expect(vec[104] == false) catch @panic("test failure");
3759 expect(vec[105] == true) catch @panic("test failure");
3760 expect(vec[106] == false) catch @panic("test failure");
3761 expect(vec[107] == true) catch @panic("test failure");
3762 expect(vec[108] == false) catch @panic("test failure");
3763 expect(vec[109] == false) catch @panic("test failure");
3764 expect(vec[110] == false) catch @panic("test failure");
3765 expect(vec[111] == false) catch @panic("test failure");
3766 expect(vec[112] == false) catch @panic("test failure");
3767 expect(vec[113] == false) catch @panic("test failure");
3768 expect(vec[114] == false) catch @panic("test failure");
3769 expect(vec[115] == false) catch @panic("test failure");
3770 expect(vec[116] == false) catch @panic("test failure");
3771 expect(vec[117] == false) catch @panic("test failure");
3772 expect(vec[118] == false) catch @panic("test failure");
3773 expect(vec[119] == false) catch @panic("test failure");
3774 expect(vec[120] == false) catch @panic("test failure");
3775 expect(vec[121] == false) catch @panic("test failure");
3776 expect(vec[122] == true) catch @panic("test failure");
3777 expect(vec[123] == true) catch @panic("test failure");
3778 expect(vec[124] == false) catch @panic("test failure");
3779 expect(vec[125] == false) catch @panic("test failure");
3780 expect(vec[126] == false) catch @panic("test failure");
3781 expect(vec[127] == true) catch @panic("test failure");
3782 expect(vec[128] == true) catch @panic("test failure");
3783 expect(vec[129] == true) catch @panic("test failure");
3784 expect(vec[130] == true) catch @panic("test failure");
3785 expect(vec[131] == false) catch @panic("test failure");
3786 expect(vec[132] == false) catch @panic("test failure");
3787 expect(vec[133] == false) catch @panic("test failure");
3788 expect(vec[134] == true) catch @panic("test failure");
3789 expect(vec[135] == true) catch @panic("test failure");
3790 expect(vec[136] == false) catch @panic("test failure");
3791 expect(vec[137] == false) catch @panic("test failure");
3792 expect(vec[138] == true) catch @panic("test failure");
3793 expect(vec[139] == true) catch @panic("test failure");
3794 expect(vec[140] == true) catch @panic("test failure");
3795 expect(vec[141] == true) catch @panic("test failure");
3796 expect(vec[142] == true) catch @panic("test failure");
3797 expect(vec[143] == false) catch @panic("test failure");
3798 expect(vec[144] == true) catch @panic("test failure");
3799 expect(vec[145] == true) catch @panic("test failure");
3800 expect(vec[146] == true) catch @panic("test failure");
3801 expect(vec[147] == false) catch @panic("test failure");
3802 expect(vec[148] == false) catch @panic("test failure");
3803 expect(vec[149] == false) catch @panic("test failure");
3804 expect(vec[150] == false) catch @panic("test failure");
3805 expect(vec[151] == false) catch @panic("test failure");
3806 expect(vec[152] == false) catch @panic("test failure");
3807 expect(vec[153] == false) catch @panic("test failure");
3808 expect(vec[154] == true) catch @panic("test failure");
3809 expect(vec[155] == false) catch @panic("test failure");
3810 expect(vec[156] == false) catch @panic("test failure");
3811 expect(vec[157] == false) catch @panic("test failure");
3812 expect(vec[158] == true) catch @panic("test failure");
3813 expect(vec[159] == true) catch @panic("test failure");
3814 expect(vec[160] == false) catch @panic("test failure");
3815 expect(vec[161] == true) catch @panic("test failure");
3816 expect(vec[162] == false) catch @panic("test failure");
3817 expect(vec[163] == false) catch @panic("test failure");
3818 expect(vec[164] == false) catch @panic("test failure");
3819 expect(vec[165] == true) catch @panic("test failure");
3820 expect(vec[166] == false) catch @panic("test failure");
3821 expect(vec[167] == true) catch @panic("test failure");
3822 expect(vec[168] == false) catch @panic("test failure");
3823 expect(vec[169] == false) catch @panic("test failure");
3824 expect(vec[170] == false) catch @panic("test failure");
3825 expect(vec[171] == false) catch @panic("test failure");
3826 expect(vec[172] == true) catch @panic("test failure");
3827 expect(vec[173] == true) catch @panic("test failure");
3828 expect(vec[174] == true) catch @panic("test failure");
3829 expect(vec[175] == true) catch @panic("test failure");
3830 expect(vec[176] == true) catch @panic("test failure");
3831 expect(vec[177] == true) catch @panic("test failure");
3832 expect(vec[178] == false) catch @panic("test failure");
3833 expect(vec[179] == true) catch @panic("test failure");
3834 expect(vec[180] == true) catch @panic("test failure");
3835 expect(vec[181] == false) catch @panic("test failure");
3836 expect(vec[182] == true) catch @panic("test failure");
3837 expect(vec[183] == false) catch @panic("test failure");
3838 expect(vec[184] == true) catch @panic("test failure");
3839 expect(vec[185] == false) catch @panic("test failure");
3840 expect(vec[186] == true) catch @panic("test failure");
3841 expect(vec[187] == false) catch @panic("test failure");
3842 expect(vec[188] == true) catch @panic("test failure");
3843 expect(vec[189] == false) catch @panic("test failure");
3844 expect(vec[190] == false) catch @panic("test failure");
3845 expect(vec[191] == false) catch @panic("test failure");
3846 expect(vec[192] == false) catch @panic("test failure");
3847 expect(vec[193] == true) catch @panic("test failure");
3848 expect(vec[194] == true) catch @panic("test failure");
3849 expect(vec[195] == true) catch @panic("test failure");
3850 expect(vec[196] == false) catch @panic("test failure");
3851 expect(vec[197] == false) catch @panic("test failure");
3852 expect(vec[198] == true) catch @panic("test failure");
3853 expect(vec[199] == false) catch @panic("test failure");
3854 expect(vec[200] == false) catch @panic("test failure");
3855 expect(vec[201] == true) catch @panic("test failure");
3856 expect(vec[202] == true) catch @panic("test failure");
3857 expect(vec[203] == false) catch @panic("test failure");
3858 expect(vec[204] == true) catch @panic("test failure");
3859 expect(vec[205] == false) catch @panic("test failure");
3860 expect(vec[206] == true) catch @panic("test failure");
3861 expect(vec[207] == false) catch @panic("test failure");
3862 expect(vec[208] == false) catch @panic("test failure");
3863 expect(vec[209] == false) catch @panic("test failure");
3864 expect(vec[210] == true) catch @panic("test failure");
3865 expect(vec[211] == true) catch @panic("test failure");
3866 expect(vec[212] == false) catch @panic("test failure");
3867 expect(vec[213] == false) catch @panic("test failure");
3868 expect(vec[214] == false) catch @panic("test failure");
3869 expect(vec[215] == true) catch @panic("test failure");
3870 expect(vec[216] == false) catch @panic("test failure");
3871 expect(vec[217] == true) catch @panic("test failure");
3872 expect(vec[218] == true) catch @panic("test failure");
3873 expect(vec[219] == true) catch @panic("test failure");
3874 expect(vec[220] == false) catch @panic("test failure");
3875 expect(vec[221] == true) catch @panic("test failure");
3876 expect(vec[222] == false) catch @panic("test failure");
3877 expect(vec[223] == true) catch @panic("test failure");
3878 expect(vec[224] == false) catch @panic("test failure");
3879 expect(vec[225] == false) catch @panic("test failure");
3880 expect(vec[226] == false) catch @panic("test failure");
3881 expect(vec[227] == true) catch @panic("test failure");
3882 expect(vec[228] == true) catch @panic("test failure");
3883 expect(vec[229] == false) catch @panic("test failure");
3884 expect(vec[230] == false) catch @panic("test failure");
3885 expect(vec[231] == false) catch @panic("test failure");
3886 expect(vec[232] == false) catch @panic("test failure");
3887 expect(vec[233] == false) catch @panic("test failure");
3888 expect(vec[234] == true) catch @panic("test failure");
3889 expect(vec[235] == false) catch @panic("test failure");
3890 expect(vec[236] == false) catch @panic("test failure");
3891 expect(vec[237] == false) catch @panic("test failure");
3892 expect(vec[238] == true) catch @panic("test failure");
3893 expect(vec[239] == false) catch @panic("test failure");
3894 expect(vec[240] == true) catch @panic("test failure");
3895 expect(vec[241] == true) catch @panic("test failure");
3896 expect(vec[242] == true) catch @panic("test failure");
3897 expect(vec[243] == false) catch @panic("test failure");
3898 expect(vec[244] == false) catch @panic("test failure");
3899 expect(vec[245] == true) catch @panic("test failure");
3900 expect(vec[246] == false) catch @panic("test failure");
3901 expect(vec[247] == false) catch @panic("test failure");
3902 expect(vec[248] == false) catch @panic("test failure");
3903 expect(vec[249] == true) catch @panic("test failure");
3904 expect(vec[250] == false) catch @panic("test failure");
3905 expect(vec[251] == false) catch @panic("test failure");
3906 expect(vec[252] == true) catch @panic("test failure");
3907 expect(vec[253] == true) catch @panic("test failure");
3908 expect(vec[254] == true) catch @panic("test failure");
3909 expect(vec[255] == true) catch @panic("test failure");
3910 }
3911
3912 export fn zig_vector_512_bool(vec: Vector512Bool) void {
3913 expect(vec[0] == false) catch @panic("test failure");
3914 expect(vec[1] == true) catch @panic("test failure");
3915 expect(vec[2] == true) catch @panic("test failure");
3916 expect(vec[3] == false) catch @panic("test failure");
3917 expect(vec[4] == true) catch @panic("test failure");
3918 expect(vec[5] == false) catch @panic("test failure");
3919 expect(vec[6] == true) catch @panic("test failure");
3920 expect(vec[7] == false) catch @panic("test failure");
3921 expect(vec[8] == false) catch @panic("test failure");
3922 expect(vec[9] == false) catch @panic("test failure");
3923 expect(vec[10] == false) catch @panic("test failure");
3924 expect(vec[11] == false) catch @panic("test failure");
3925 expect(vec[12] == true) catch @panic("test failure");
3926 expect(vec[13] == false) catch @panic("test failure");
3927 expect(vec[14] == true) catch @panic("test failure");
3928 expect(vec[15] == false) catch @panic("test failure");
3929 expect(vec[16] == false) catch @panic("test failure");
3930 expect(vec[17] == false) catch @panic("test failure");
3931 expect(vec[18] == true) catch @panic("test failure");
3932 expect(vec[19] == true) catch @panic("test failure");
3933 expect(vec[20] == true) catch @panic("test failure");
3934 expect(vec[21] == true) catch @panic("test failure");
3935 expect(vec[22] == false) catch @panic("test failure");
3936 expect(vec[23] == false) catch @panic("test failure");
3937 expect(vec[24] == false) catch @panic("test failure");
3938 expect(vec[25] == true) catch @panic("test failure");
3939 expect(vec[26] == true) catch @panic("test failure");
3940 expect(vec[27] == false) catch @panic("test failure");
3941 expect(vec[28] == true) catch @panic("test failure");
3942 expect(vec[29] == true) catch @panic("test failure");
3943 expect(vec[30] == false) catch @panic("test failure");
3944 expect(vec[31] == false) catch @panic("test failure");
3945 expect(vec[32] == true) catch @panic("test failure");
3946 expect(vec[33] == true) catch @panic("test failure");
3947 expect(vec[34] == false) catch @panic("test failure");
3948 expect(vec[35] == false) catch @panic("test failure");
3949 expect(vec[36] == false) catch @panic("test failure");
3950 expect(vec[37] == false) catch @panic("test failure");
3951 expect(vec[38] == false) catch @panic("test failure");
3952 expect(vec[39] == false) catch @panic("test failure");
3953 expect(vec[40] == false) catch @panic("test failure");
3954 expect(vec[41] == true) catch @panic("test failure");
3955 expect(vec[42] == true) catch @panic("test failure");
3956 expect(vec[43] == true) catch @panic("test failure");
3957 expect(vec[44] == false) catch @panic("test failure");
3958 expect(vec[45] == true) catch @panic("test failure");
3959 expect(vec[46] == true) catch @panic("test failure");
3960 expect(vec[47] == true) catch @panic("test failure");
3961 expect(vec[48] == true) catch @panic("test failure");
3962 expect(vec[49] == true) catch @panic("test failure");
3963 expect(vec[50] == false) catch @panic("test failure");
3964 expect(vec[51] == true) catch @panic("test failure");
3965 expect(vec[52] == true) catch @panic("test failure");
3966 expect(vec[53] == true) catch @panic("test failure");
3967 expect(vec[54] == false) catch @panic("test failure");
3968 expect(vec[55] == true) catch @panic("test failure");
3969 expect(vec[56] == false) catch @panic("test failure");
3970 expect(vec[57] == false) catch @panic("test failure");
3971 expect(vec[58] == true) catch @panic("test failure");
3972 expect(vec[59] == false) catch @panic("test failure");
3973 expect(vec[60] == true) catch @panic("test failure");
3974 expect(vec[61] == true) catch @panic("test failure");
3975 expect(vec[62] == false) catch @panic("test failure");
3976 expect(vec[63] == false) catch @panic("test failure");
3977 expect(vec[64] == false) catch @panic("test failure");
3978 expect(vec[65] == true) catch @panic("test failure");
3979 expect(vec[66] == true) catch @panic("test failure");
3980 expect(vec[67] == true) catch @panic("test failure");
3981 expect(vec[68] == true) catch @panic("test failure");
3982 expect(vec[69] == false) catch @panic("test failure");
3983 expect(vec[70] == false) catch @panic("test failure");
3984 expect(vec[71] == true) catch @panic("test failure");
3985 expect(vec[72] == true) catch @panic("test failure");
3986 expect(vec[73] == false) catch @panic("test failure");
3987 expect(vec[74] == true) catch @panic("test failure");
3988 expect(vec[75] == true) catch @panic("test failure");
3989 expect(vec[76] == false) catch @panic("test failure");
3990 expect(vec[77] == false) catch @panic("test failure");
3991 expect(vec[78] == true) catch @panic("test failure");
3992 expect(vec[79] == false) catch @panic("test failure");
3993 expect(vec[80] == false) catch @panic("test failure");
3994 expect(vec[81] == false) catch @panic("test failure");
3995 expect(vec[82] == true) catch @panic("test failure");
3996 expect(vec[83] == true) catch @panic("test failure");
3997 expect(vec[84] == true) catch @panic("test failure");
3998 expect(vec[85] == false) catch @panic("test failure");
3999 expect(vec[86] == false) catch @panic("test failure");
4000 expect(vec[87] == true) catch @panic("test failure");
4001 expect(vec[88] == false) catch @panic("test failure");
4002 expect(vec[89] == true) catch @panic("test failure");
4003 expect(vec[90] == false) catch @panic("test failure");
4004 expect(vec[91] == false) catch @panic("test failure");
4005 expect(vec[92] == true) catch @panic("test failure");
4006 expect(vec[93] == false) catch @panic("test failure");
4007 expect(vec[94] == false) catch @panic("test failure");
4008 expect(vec[95] == true) catch @panic("test failure");
4009 expect(vec[96] == true) catch @panic("test failure");
4010 expect(vec[97] == false) catch @panic("test failure");
4011 expect(vec[98] == false) catch @panic("test failure");
4012 expect(vec[99] == false) catch @panic("test failure");
4013 expect(vec[100] == false) catch @panic("test failure");
4014 expect(vec[101] == true) catch @panic("test failure");
4015 expect(vec[102] == false) catch @panic("test failure");
4016 expect(vec[103] == false) catch @panic("test failure");
4017 expect(vec[104] == false) catch @panic("test failure");
4018 expect(vec[105] == false) catch @panic("test failure");
4019 expect(vec[106] == false) catch @panic("test failure");
4020 expect(vec[107] == false) catch @panic("test failure");
4021 expect(vec[108] == true) catch @panic("test failure");
4022 expect(vec[109] == true) catch @panic("test failure");
4023 expect(vec[110] == true) catch @panic("test failure");
4024 expect(vec[111] == true) catch @panic("test failure");
4025 expect(vec[112] == true) catch @panic("test failure");
4026 expect(vec[113] == false) catch @panic("test failure");
4027 expect(vec[114] == false) catch @panic("test failure");
4028 expect(vec[115] == false) catch @panic("test failure");
4029 expect(vec[116] == false) catch @panic("test failure");
4030 expect(vec[117] == true) catch @panic("test failure");
4031 expect(vec[118] == true) catch @panic("test failure");
4032 expect(vec[119] == false) catch @panic("test failure");
4033 expect(vec[120] == true) catch @panic("test failure");
4034 expect(vec[121] == true) catch @panic("test failure");
4035 expect(vec[122] == false) catch @panic("test failure");
4036 expect(vec[123] == false) catch @panic("test failure");
4037 expect(vec[124] == true) catch @panic("test failure");
4038 expect(vec[125] == false) catch @panic("test failure");
4039 expect(vec[126] == false) catch @panic("test failure");
4040 expect(vec[127] == false) catch @panic("test failure");
4041 expect(vec[128] == false) catch @panic("test failure");
4042 expect(vec[129] == true) catch @panic("test failure");
4043 expect(vec[130] == true) catch @panic("test failure");
4044 expect(vec[131] == true) catch @panic("test failure");
4045 expect(vec[132] == true) catch @panic("test failure");
4046 expect(vec[133] == false) catch @panic("test failure");
4047 expect(vec[134] == false) catch @panic("test failure");
4048 expect(vec[135] == false) catch @panic("test failure");
4049 expect(vec[136] == false) catch @panic("test failure");
4050 expect(vec[137] == true) catch @panic("test failure");
4051 expect(vec[138] == false) catch @panic("test failure");
4052 expect(vec[139] == false) catch @panic("test failure");
4053 expect(vec[140] == false) catch @panic("test failure");
4054 expect(vec[141] == false) catch @panic("test failure");
4055 expect(vec[142] == true) catch @panic("test failure");
4056 expect(vec[143] == true) catch @panic("test failure");
4057 expect(vec[144] == false) catch @panic("test failure");
4058 expect(vec[145] == true) catch @panic("test failure");
4059 expect(vec[146] == false) catch @panic("test failure");
4060 expect(vec[147] == true) catch @panic("test failure");
4061 expect(vec[148] == false) catch @panic("test failure");
4062 expect(vec[149] == false) catch @panic("test failure");
4063 expect(vec[150] == true) catch @panic("test failure");
4064 expect(vec[151] == true) catch @panic("test failure");
4065 expect(vec[152] == false) catch @panic("test failure");
4066 expect(vec[153] == true) catch @panic("test failure");
4067 expect(vec[154] == true) catch @panic("test failure");
4068 expect(vec[155] == false) catch @panic("test failure");
4069 expect(vec[156] == false) catch @panic("test failure");
4070 expect(vec[157] == false) catch @panic("test failure");
4071 expect(vec[158] == true) catch @panic("test failure");
4072 expect(vec[159] == false) catch @panic("test failure");
4073 expect(vec[160] == false) catch @panic("test failure");
4074 expect(vec[161] == false) catch @panic("test failure");
4075 expect(vec[162] == false) catch @panic("test failure");
4076 expect(vec[163] == true) catch @panic("test failure");
4077 expect(vec[164] == true) catch @panic("test failure");
4078 expect(vec[165] == false) catch @panic("test failure");
4079 expect(vec[166] == false) catch @panic("test failure");
4080 expect(vec[167] == true) catch @panic("test failure");
4081 expect(vec[168] == false) catch @panic("test failure");
4082 expect(vec[169] == true) catch @panic("test failure");
4083 expect(vec[170] == true) catch @panic("test failure");
4084 expect(vec[171] == false) catch @panic("test failure");
4085 expect(vec[172] == false) catch @panic("test failure");
4086 expect(vec[173] == false) catch @panic("test failure");
4087 expect(vec[174] == false) catch @panic("test failure");
4088 expect(vec[175] == false) catch @panic("test failure");
4089 expect(vec[176] == false) catch @panic("test failure");
4090 expect(vec[177] == true) catch @panic("test failure");
4091 expect(vec[178] == false) catch @panic("test failure");
4092 expect(vec[179] == false) catch @panic("test failure");
4093 expect(vec[180] == false) catch @panic("test failure");
4094 expect(vec[181] == false) catch @panic("test failure");
4095 expect(vec[182] == false) catch @panic("test failure");
4096 expect(vec[183] == false) catch @panic("test failure");
4097 expect(vec[184] == true) catch @panic("test failure");
4098 expect(vec[185] == false) catch @panic("test failure");
4099 expect(vec[186] == false) catch @panic("test failure");
4100 expect(vec[187] == false) catch @panic("test failure");
4101 expect(vec[188] == false) catch @panic("test failure");
4102 expect(vec[189] == true) catch @panic("test failure");
4103 expect(vec[190] == false) catch @panic("test failure");
4104 expect(vec[191] == false) catch @panic("test failure");
4105 expect(vec[192] == false) catch @panic("test failure");
4106 expect(vec[193] == false) catch @panic("test failure");
4107 expect(vec[194] == false) catch @panic("test failure");
4108 expect(vec[195] == false) catch @panic("test failure");
4109 expect(vec[196] == true) catch @panic("test failure");
4110 expect(vec[197] == true) catch @panic("test failure");
4111 expect(vec[198] == true) catch @panic("test failure");
4112 expect(vec[199] == false) catch @panic("test failure");
4113 expect(vec[200] == true) catch @panic("test failure");
4114 expect(vec[201] == true) catch @panic("test failure");
4115 expect(vec[202] == false) catch @panic("test failure");
4116 expect(vec[203] == false) catch @panic("test failure");
4117 expect(vec[204] == false) catch @panic("test failure");
4118 expect(vec[205] == false) catch @panic("test failure");
4119 expect(vec[206] == false) catch @panic("test failure");
4120 expect(vec[207] == true) catch @panic("test failure");
4121 expect(vec[208] == true) catch @panic("test failure");
4122 expect(vec[209] == false) catch @panic("test failure");
4123 expect(vec[210] == false) catch @panic("test failure");
4124 expect(vec[211] == false) catch @panic("test failure");
4125 expect(vec[212] == true) catch @panic("test failure");
4126 expect(vec[213] == false) catch @panic("test failure");
4127 expect(vec[214] == false) catch @panic("test failure");
4128 expect(vec[215] == true) catch @panic("test failure");
4129 expect(vec[216] == true) catch @panic("test failure");
4130 expect(vec[217] == true) catch @panic("test failure");
4131 expect(vec[218] == false) catch @panic("test failure");
4132 expect(vec[219] == false) catch @panic("test failure");
4133 expect(vec[220] == true) catch @panic("test failure");
4134 expect(vec[221] == false) catch @panic("test failure");
4135 expect(vec[222] == true) catch @panic("test failure");
4136 expect(vec[223] == true) catch @panic("test failure");
4137 expect(vec[224] == true) catch @panic("test failure");
4138 expect(vec[225] == true) catch @panic("test failure");
4139 expect(vec[226] == false) catch @panic("test failure");
4140 expect(vec[227] == true) catch @panic("test failure");
4141 expect(vec[228] == false) catch @panic("test failure");
4142 expect(vec[229] == false) catch @panic("test failure");
4143 expect(vec[230] == false) catch @panic("test failure");
4144 expect(vec[231] == true) catch @panic("test failure");
4145 expect(vec[232] == false) catch @panic("test failure");
4146 expect(vec[233] == false) catch @panic("test failure");
4147 expect(vec[234] == false) catch @panic("test failure");
4148 expect(vec[235] == false) catch @panic("test failure");
4149 expect(vec[236] == false) catch @panic("test failure");
4150 expect(vec[237] == false) catch @panic("test failure");
4151 expect(vec[238] == false) catch @panic("test failure");
4152 expect(vec[239] == true) catch @panic("test failure");
4153 expect(vec[240] == false) catch @panic("test failure");
4154 expect(vec[241] == false) catch @panic("test failure");
4155 expect(vec[242] == false) catch @panic("test failure");
4156 expect(vec[243] == true) catch @panic("test failure");
4157 expect(vec[244] == true) catch @panic("test failure");
4158 expect(vec[245] == true) catch @panic("test failure");
4159 expect(vec[246] == true) catch @panic("test failure");
4160 expect(vec[247] == false) catch @panic("test failure");
4161 expect(vec[248] == true) catch @panic("test failure");
4162 expect(vec[249] == true) catch @panic("test failure");
4163 expect(vec[250] == false) catch @panic("test failure");
4164 expect(vec[251] == false) catch @panic("test failure");
4165 expect(vec[252] == false) catch @panic("test failure");
4166 expect(vec[253] == true) catch @panic("test failure");
4167 expect(vec[254] == false) catch @panic("test failure");
4168 expect(vec[255] == false) catch @panic("test failure");
4169 expect(vec[256] == true) catch @panic("test failure");
4170 expect(vec[257] == true) catch @panic("test failure");
4171 expect(vec[258] == false) catch @panic("test failure");
4172 expect(vec[259] == true) catch @panic("test failure");
4173 expect(vec[260] == false) catch @panic("test failure");
4174 expect(vec[261] == true) catch @panic("test failure");
4175 expect(vec[262] == true) catch @panic("test failure");
4176 expect(vec[263] == false) catch @panic("test failure");
4177 expect(vec[264] == false) catch @panic("test failure");
4178 expect(vec[265] == false) catch @panic("test failure");
4179 expect(vec[266] == false) catch @panic("test failure");
4180 expect(vec[267] == true) catch @panic("test failure");
4181 expect(vec[268] == false) catch @panic("test failure");
4182 expect(vec[269] == true) catch @panic("test failure");
4183 expect(vec[270] == true) catch @panic("test failure");
4184 expect(vec[271] == false) catch @panic("test failure");
4185 expect(vec[272] == false) catch @panic("test failure");
4186 expect(vec[273] == true) catch @panic("test failure");
4187 expect(vec[274] == true) catch @panic("test failure");
4188 expect(vec[275] == true) catch @panic("test failure");
4189 expect(vec[276] == false) catch @panic("test failure");
4190 expect(vec[277] == true) catch @panic("test failure");
4191 expect(vec[278] == false) catch @panic("test failure");
4192 expect(vec[279] == false) catch @panic("test failure");
4193 expect(vec[280] == true) catch @panic("test failure");
4194 expect(vec[281] == true) catch @panic("test failure");
4195 expect(vec[282] == false) catch @panic("test failure");
4196 expect(vec[283] == true) catch @panic("test failure");
4197 expect(vec[284] == false) catch @panic("test failure");
4198 expect(vec[285] == true) catch @panic("test failure");
4199 expect(vec[286] == true) catch @panic("test failure");
4200 expect(vec[287] == true) catch @panic("test failure");
4201 expect(vec[288] == true) catch @panic("test failure");
4202 expect(vec[289] == true) catch @panic("test failure");
4203 expect(vec[290] == true) catch @panic("test failure");
4204 expect(vec[291] == true) catch @panic("test failure");
4205 expect(vec[292] == true) catch @panic("test failure");
4206 expect(vec[293] == true) catch @panic("test failure");
4207 expect(vec[294] == true) catch @panic("test failure");
4208 expect(vec[295] == false) catch @panic("test failure");
4209 expect(vec[296] == true) catch @panic("test failure");
4210 expect(vec[297] == false) catch @panic("test failure");
4211 expect(vec[298] == true) catch @panic("test failure");
4212 expect(vec[299] == false) catch @panic("test failure");
4213 expect(vec[300] == true) catch @panic("test failure");
4214 expect(vec[301] == true) catch @panic("test failure");
4215 expect(vec[302] == false) catch @panic("test failure");
4216 expect(vec[303] == true) catch @panic("test failure");
4217 expect(vec[304] == false) catch @panic("test failure");
4218 expect(vec[305] == true) catch @panic("test failure");
4219 expect(vec[306] == false) catch @panic("test failure");
4220 expect(vec[307] == true) catch @panic("test failure");
4221 expect(vec[308] == true) catch @panic("test failure");
4222 expect(vec[309] == false) catch @panic("test failure");
4223 expect(vec[310] == true) catch @panic("test failure");
4224 expect(vec[311] == true) catch @panic("test failure");
4225 expect(vec[312] == true) catch @panic("test failure");
4226 expect(vec[313] == false) catch @panic("test failure");
4227 expect(vec[314] == false) catch @panic("test failure");
4228 expect(vec[315] == false) catch @panic("test failure");
4229 expect(vec[316] == false) catch @panic("test failure");
4230 expect(vec[317] == true) catch @panic("test failure");
4231 expect(vec[318] == true) catch @panic("test failure");
4232 expect(vec[319] == true) catch @panic("test failure");
4233 expect(vec[320] == true) catch @panic("test failure");
4234 expect(vec[321] == true) catch @panic("test failure");
4235 expect(vec[322] == true) catch @panic("test failure");
4236 expect(vec[323] == true) catch @panic("test failure");
4237 expect(vec[324] == true) catch @panic("test failure");
4238 expect(vec[325] == true) catch @panic("test failure");
4239 expect(vec[326] == false) catch @panic("test failure");
4240 expect(vec[327] == true) catch @panic("test failure");
4241 expect(vec[328] == false) catch @panic("test failure");
4242 expect(vec[329] == false) catch @panic("test failure");
4243 expect(vec[330] == true) catch @panic("test failure");
4244 expect(vec[331] == false) catch @panic("test failure");
4245 expect(vec[332] == false) catch @panic("test failure");
4246 expect(vec[333] == false) catch @panic("test failure");
4247 expect(vec[334] == false) catch @panic("test failure");
4248 expect(vec[335] == false) catch @panic("test failure");
4249 expect(vec[336] == false) catch @panic("test failure");
4250 expect(vec[337] == false) catch @panic("test failure");
4251 expect(vec[338] == false) catch @panic("test failure");
4252 expect(vec[339] == false) catch @panic("test failure");
4253 expect(vec[340] == false) catch @panic("test failure");
4254 expect(vec[341] == false) catch @panic("test failure");
4255 expect(vec[342] == true) catch @panic("test failure");
4256 expect(vec[343] == true) catch @panic("test failure");
4257 expect(vec[344] == false) catch @panic("test failure");
4258 expect(vec[345] == false) catch @panic("test failure");
4259 expect(vec[346] == false) catch @panic("test failure");
4260 expect(vec[347] == false) catch @panic("test failure");
4261 expect(vec[348] == false) catch @panic("test failure");
4262 expect(vec[349] == true) catch @panic("test failure");
4263 expect(vec[350] == true) catch @panic("test failure");
4264 expect(vec[351] == true) catch @panic("test failure");
4265 expect(vec[352] == true) catch @panic("test failure");
4266 expect(vec[353] == false) catch @panic("test failure");
4267 expect(vec[354] == false) catch @panic("test failure");
4268 expect(vec[355] == false) catch @panic("test failure");
4269 expect(vec[356] == false) catch @panic("test failure");
4270 expect(vec[357] == true) catch @panic("test failure");
4271 expect(vec[358] == true) catch @panic("test failure");
4272 expect(vec[359] == false) catch @panic("test failure");
4273 expect(vec[360] == false) catch @panic("test failure");
4274 expect(vec[361] == false) catch @panic("test failure");
4275 expect(vec[362] == true) catch @panic("test failure");
4276 expect(vec[363] == true) catch @panic("test failure");
4277 expect(vec[364] == false) catch @panic("test failure");
4278 expect(vec[365] == false) catch @panic("test failure");
4279 expect(vec[366] == false) catch @panic("test failure");
4280 expect(vec[367] == false) catch @panic("test failure");
4281 expect(vec[368] == false) catch @panic("test failure");
4282 expect(vec[369] == true) catch @panic("test failure");
4283 expect(vec[370] == true) catch @panic("test failure");
4284 expect(vec[371] == false) catch @panic("test failure");
4285 expect(vec[372] == true) catch @panic("test failure");
4286 expect(vec[373] == true) catch @panic("test failure");
4287 expect(vec[374] == false) catch @panic("test failure");
4288 expect(vec[375] == true) catch @panic("test failure");
4289 expect(vec[376] == true) catch @panic("test failure");
4290 expect(vec[377] == false) catch @panic("test failure");
4291 expect(vec[378] == true) catch @panic("test failure");
4292 expect(vec[379] == true) catch @panic("test failure");
4293 expect(vec[380] == false) catch @panic("test failure");
4294 expect(vec[381] == true) catch @panic("test failure");
4295 expect(vec[382] == true) catch @panic("test failure");
4296 expect(vec[383] == false) catch @panic("test failure");
4297 expect(vec[384] == true) catch @panic("test failure");
4298 expect(vec[385] == false) catch @panic("test failure");
4299 expect(vec[386] == true) catch @panic("test failure");
4300 expect(vec[387] == true) catch @panic("test failure");
4301 expect(vec[388] == true) catch @panic("test failure");
4302 expect(vec[389] == true) catch @panic("test failure");
4303 expect(vec[390] == false) catch @panic("test failure");
4304 expect(vec[391] == false) catch @panic("test failure");
4305 expect(vec[392] == false) catch @panic("test failure");
4306 expect(vec[393] == true) catch @panic("test failure");
4307 expect(vec[394] == true) catch @panic("test failure");
4308 expect(vec[395] == true) catch @panic("test failure");
4309 expect(vec[396] == true) catch @panic("test failure");
4310 expect(vec[397] == false) catch @panic("test failure");
4311 expect(vec[398] == true) catch @panic("test failure");
4312 expect(vec[399] == true) catch @panic("test failure");
4313 expect(vec[400] == true) catch @panic("test failure");
4314 expect(vec[401] == false) catch @panic("test failure");
4315 expect(vec[402] == false) catch @panic("test failure");
4316 expect(vec[403] == true) catch @panic("test failure");
4317 expect(vec[404] == false) catch @panic("test failure");
4318 expect(vec[405] == false) catch @panic("test failure");
4319 expect(vec[406] == false) catch @panic("test failure");
4320 expect(vec[407] == true) catch @panic("test failure");
4321 expect(vec[408] == true) catch @panic("test failure");
4322 expect(vec[409] == true) catch @panic("test failure");
4323 expect(vec[410] == false) catch @panic("test failure");
4324 expect(vec[411] == true) catch @panic("test failure");
4325 expect(vec[412] == false) catch @panic("test failure");
4326 expect(vec[413] == false) catch @panic("test failure");
4327 expect(vec[414] == false) catch @panic("test failure");
4328 expect(vec[415] == true) catch @panic("test failure");
4329 expect(vec[416] == false) catch @panic("test failure");
4330 expect(vec[417] == false) catch @panic("test failure");
4331 expect(vec[418] == true) catch @panic("test failure");
4332 expect(vec[419] == true) catch @panic("test failure");
4333 expect(vec[420] == true) catch @panic("test failure");
4334 expect(vec[421] == true) catch @panic("test failure");
4335 expect(vec[422] == false) catch @panic("test failure");
4336 expect(vec[423] == true) catch @panic("test failure");
4337 expect(vec[424] == true) catch @panic("test failure");
4338 expect(vec[425] == false) catch @panic("test failure");
4339 expect(vec[426] == false) catch @panic("test failure");
4340 expect(vec[427] == false) catch @panic("test failure");
4341 expect(vec[428] == true) catch @panic("test failure");
4342 expect(vec[429] == false) catch @panic("test failure");
4343 expect(vec[430] == true) catch @panic("test failure");
4344 expect(vec[431] == true) catch @panic("test failure");
4345 expect(vec[432] == false) catch @panic("test failure");
4346 expect(vec[433] == false) catch @panic("test failure");
4347 expect(vec[434] == false) catch @panic("test failure");
4348 expect(vec[435] == false) catch @panic("test failure");
4349 expect(vec[436] == true) catch @panic("test failure");
4350 expect(vec[437] == false) catch @panic("test failure");
4351 expect(vec[438] == true) catch @panic("test failure");
4352 expect(vec[439] == false) catch @panic("test failure");
4353 expect(vec[440] == false) catch @panic("test failure");
4354 expect(vec[441] == false) catch @panic("test failure");
4355 expect(vec[442] == false) catch @panic("test failure");
4356 expect(vec[443] == true) catch @panic("test failure");
4357 expect(vec[444] == false) catch @panic("test failure");
4358 expect(vec[445] == false) catch @panic("test failure");
4359 expect(vec[446] == true) catch @panic("test failure");
4360 expect(vec[447] == true) catch @panic("test failure");
4361 expect(vec[448] == true) catch @panic("test failure");
4362 expect(vec[449] == false) catch @panic("test failure");
4363 expect(vec[450] == true) catch @panic("test failure");
4364 expect(vec[451] == true) catch @panic("test failure");
4365 expect(vec[452] == false) catch @panic("test failure");
4366 expect(vec[453] == true) catch @panic("test failure");
4367 expect(vec[454] == false) catch @panic("test failure");
4368 expect(vec[455] == true) catch @panic("test failure");
4369 expect(vec[456] == false) catch @panic("test failure");
4370 expect(vec[457] == false) catch @panic("test failure");
4371 expect(vec[458] == false) catch @panic("test failure");
4372 expect(vec[459] == true) catch @panic("test failure");
4373 expect(vec[460] == false) catch @panic("test failure");
4374 expect(vec[461] == false) catch @panic("test failure");
4375 expect(vec[462] == false) catch @panic("test failure");
4376 expect(vec[463] == true) catch @panic("test failure");
4377 expect(vec[464] == true) catch @panic("test failure");
4378 expect(vec[465] == true) catch @panic("test failure");
4379 expect(vec[466] == true) catch @panic("test failure");
4380 expect(vec[467] == true) catch @panic("test failure");
4381 expect(vec[468] == false) catch @panic("test failure");
4382 expect(vec[469] == false) catch @panic("test failure");
4383 expect(vec[470] == false) catch @panic("test failure");
4384 expect(vec[471] == false) catch @panic("test failure");
4385 expect(vec[472] == false) catch @panic("test failure");
4386 expect(vec[473] == false) catch @panic("test failure");
4387 expect(vec[474] == true) catch @panic("test failure");
4388 expect(vec[475] == true) catch @panic("test failure");
4389 expect(vec[476] == true) catch @panic("test failure");
4390 expect(vec[477] == true) catch @panic("test failure");
4391 expect(vec[478] == true) catch @panic("test failure");
4392 expect(vec[479] == false) catch @panic("test failure");
4393 expect(vec[480] == true) catch @panic("test failure");
4394 expect(vec[481] == true) catch @panic("test failure");
4395 expect(vec[482] == false) catch @panic("test failure");
4396 expect(vec[483] == true) catch @panic("test failure");
4397 expect(vec[484] == false) catch @panic("test failure");
4398 expect(vec[485] == true) catch @panic("test failure");
4399 expect(vec[486] == false) catch @panic("test failure");
4400 expect(vec[487] == true) catch @panic("test failure");
4401 expect(vec[488] == false) catch @panic("test failure");
4402 expect(vec[489] == false) catch @panic("test failure");
4403 expect(vec[490] == false) catch @panic("test failure");
4404 expect(vec[491] == true) catch @panic("test failure");
4405 expect(vec[492] == false) catch @panic("test failure");
4406 expect(vec[493] == false) catch @panic("test failure");
4407 expect(vec[494] == false) catch @panic("test failure");
4408 expect(vec[495] == true) catch @panic("test failure");
4409 expect(vec[496] == true) catch @panic("test failure");
4410 expect(vec[497] == false) catch @panic("test failure");
4411 expect(vec[498] == false) catch @panic("test failure");
4412 expect(vec[499] == true) catch @panic("test failure");
4413 expect(vec[500] == false) catch @panic("test failure");
4414 expect(vec[501] == true) catch @panic("test failure");
4415 expect(vec[502] == false) catch @panic("test failure");
4416 expect(vec[503] == false) catch @panic("test failure");
4417 expect(vec[504] == false) catch @panic("test failure");
4418 expect(vec[505] == true) catch @panic("test failure");
4419 expect(vec[506] == true) catch @panic("test failure");
4420 expect(vec[507] == true) catch @panic("test failure");
4421 expect(vec[508] == true) catch @panic("test failure");
4422 expect(vec[509] == false) catch @panic("test failure");
4423 expect(vec[510] == false) catch @panic("test failure");
4424 expect(vec[511] == true) catch @panic("test failure");
4425 }
4426
4427 export fn zig_ret_vector_2_bool() Vector2Bool {
4428 return .{
4429 false,
4430 false,
4431 };
4432 }
4433
4434 export fn zig_ret_vector_4_bool() Vector4Bool {
4435 return .{
4436 false,
4437 true,
4438 true,
4439 true,
4440 };
4441 }
4442
4443 export fn zig_ret_vector_8_bool() Vector8Bool {
4444 return .{
4445 false,
4446 false,
4447 false,
4448 false,
4449 true,
4450 false,
4451 false,
4452 false,
4453 };
4454 }
4455
4456 export fn zig_ret_vector_16_bool() Vector16Bool {
4457 return .{
4458 false,
4459 true,
4460 false,
4461 false,
4462 false,
4463 true,
4464 false,
4465 false,
4466 true,
4467 false,
4468 false,
4469 false,
4470 false,
4471 true,
4472 false,
4473 false,
4474 };
4475 }
4476
4477 export fn zig_ret_vector_32_bool() Vector32Bool {
4478 return .{
4479 false,
4480 true,
4481 false,
4482 false,
4483 true,
4484 false,
4485 true,
4486 true,
4487 true,
4488 true,
4489 true,
4490 true,
4491 false,
4492 false,
4493 false,
4494 false,
4495 false,
4496 false,
4497 true,
4498 true,
4499 true,
4500 false,
4501 true,
4502 false,
4503 true,
4504 false,
4505 false,
4506 true,
4507 false,
4508 false,
4509 true,
4510 true,
4511 };
4512 }
4513
4514 export fn zig_ret_vector_64_bool() Vector64Bool {
4515 return .{
4516 true,
4517 false,
4518 true,
4519 false,
4520 false,
4521 true,
4522 false,
4523 true,
4524 true,
4525 false,
4526 true,
4527 false,
4528 true,
4529 false,
4530 false,
4531 true,
4532 false,
4533 false,
4534 true,
4535 true,
4536 false,
4537 false,
4538 true,
4539 false,
4540 false,
4541 true,
4542 true,
4543 true,
4544 true,
4545 true,
4546 false,
4547 false,
4548 true,
4549 true,
4550 true,
4551 true,
4552 false,
4553 true,
4554 false,
4555 true,
4556 true,
4557 true,
4558 true,
4559 true,
4560 false,
4561 false,
4562 false,
4563 true,
4564 true,
4565 true,
4566 false,
4567 true,
4568 true,
4569 true,
4570 false,
4571 false,
4572 false,
4573 true,
4574 false,
4575 false,
4576 true,
4577 false,
4578 true,
4579 false,
4580 };
4581 }
4582
4583 export fn zig_ret_vector_128_bool() Vector128Bool {
4584 return .{
4585 true,
4586 true,
4587 false,
4588 false,
4589 false,
4590 true,
4591 true,
4592 false,
4593 false,
4594 true,
4595 false,
4596 false,
4597 false,
4598 true,
4599 false,
4600 true,
4601 true,
4602 false,
4603 false,
4604 true,
4605 true,
4606 true,
4607 true,
4608 true,
4609 false,
4610 false,
4611 true,
4612 true,
4613 true,
4614 false,
4615 false,
4616 true,
4617 true,
4618 false,
4619 true,
4620 true,
4621 true,
4622 false,
4623 true,
4624 true,
4625 true,
4626 false,
4627 true,
4628 true,
4629 false,
4630 false,
4631 false,
4632 true,
4633 false,
4634 false,
4635 false,
4636 false,
4637 true,
4638 false,
4639 true,
4640 false,
4641 true,
4642 false,
4643 false,
4644 true,
4645 true,
4646 true,
4647 true,
4648 true,
4649 false,
4650 false,
4651 false,
4652 true,
4653 true,
4654 false,
4655 true,
4656 true,
4657 false,
4658 true,
4659 true,
4660 false,
4661 false,
4662 true,
4663 false,
4664 true,
4665 false,
4666 false,
4667 true,
4668 true,
4669 false,
4670 true,
4671 false,
4672 false,
4673 true,
4674 true,
4675 true,
4676 true,
4677 true,
4678 false,
4679 false,
4680 true,
4681 false,
4682 false,
4683 true,
4684 true,
4685 true,
4686 true,
4687 true,
4688 true,
4689 true,
4690 false,
4691 false,
4692 true,
4693 false,
4694 false,
4695 true,
4696 false,
4697 false,
4698 true,
4699 false,
4700 false,
4701 false,
4702 false,
4703 false,
4704 false,
4705 true,
4706 true,
4707 true,
4708 false,
4709 true,
4710 false,
4711 false,
4712 true,
4713 };
4714 }
4715
4716 export fn zig_ret_vector_256_bool() Vector256Bool {
4717 return .{
4718 true,
4719 true,
4720 true,
4721 false,
4722 true,
4723 false,
4724 false,
4725 true,
4726 false,
4727 false,
4728 false,
4729 false,
4730 false,
4731 false,
4732 false,
4733 false,
4734 true,
4735 false,
4736 true,
4737 false,
4738 false,
4739 true,
4740 true,
4741 false,
4742 false,
4743 true,
4744 true,
4745 false,
4746 true,
4747 true,
4748 true,
4749 false,
4750 true,
4751 false,
4752 true,
4753 false,
4754 true,
4755 false,
4756 true,
4757 false,
4758 false,
4759 false,
4760 true,
4761 true,
4762 true,
4763 false,
4764 false,
4765 false,
4766 true,
4767 false,
4768 true,
4769 false,
4770 true,
4771 false,
4772 true,
4773 true,
4774 false,
4775 false,
4776 false,
4777 true,
4778 true,
4779 true,
4780 false,
4781 true,
4782 false,
4783 true,
4784 false,
4785 true,
4786 true,
4787 false,
4788 true,
4789 false,
4790 true,
4791 true,
4792 false,
4793 false,
4794 false,
4795 false,
4796 false,
4797 false,
4798 false,
4799 false,
4800 false,
4801 true,
4802 false,
4803 false,
4804 false,
4805 true,
4806 false,
4807 true,
4808 true,
4809 false,
4810 false,
4811 true,
4812 true,
4813 false,
4814 false,
4815 true,
4816 false,
4817 false,
4818 false,
4819 false,
4820 false,
4821 false,
4822 false,
4823 true,
4824 true,
4825 false,
4826 true,
4827 false,
4828 true,
4829 true,
4830 false,
4831 false,
4832 false,
4833 false,
4834 false,
4835 false,
4836 false,
4837 true,
4838 true,
4839 true,
4840 false,
4841 true,
4842 true,
4843 false,
4844 false,
4845 true,
4846 true,
4847 true,
4848 true,
4849 true,
4850 false,
4851 true,
4852 true,
4853 false,
4854 false,
4855 true,
4856 true,
4857 false,
4858 true,
4859 false,
4860 true,
4861 false,
4862 true,
4863 true,
4864 true,
4865 true,
4866 false,
4867 false,
4868 false,
4869 true,
4870 false,
4871 true,
4872 false,
4873 true,
4874 true,
4875 false,
4876 true,
4877 true,
4878 true,
4879 true,
4880 true,
4881 false,
4882 false,
4883 true,
4884 false,
4885 true,
4886 true,
4887 true,
4888 true,
4889 false,
4890 true,
4891 true,
4892 true,
4893 true,
4894 true,
4895 true,
4896 true,
4897 false,
4898 true,
4899 false,
4900 false,
4901 false,
4902 true,
4903 false,
4904 true,
4905 true,
4906 false,
4907 true,
4908 false,
4909 true,
4910 false,
4911 true,
4912 false,
4913 false,
4914 true,
4915 true,
4916 true,
4917 true,
4918 true,
4919 true,
4920 true,
4921 false,
4922 true,
4923 false,
4924 false,
4925 true,
4926 true,
4927 false,
4928 false,
4929 false,
4930 true,
4931 true,
4932 true,
4933 false,
4934 false,
4935 true,
4936 true,
4937 true,
4938 true,
4939 false,
4940 true,
4941 false,
4942 true,
4943 true,
4944 true,
4945 false,
4946 false,
4947 false,
4948 false,
4949 false,
4950 true,
4951 true,
4952 false,
4953 false,
4954 false,
4955 true,
4956 true,
4957 false,
4958 true,
4959 true,
4960 true,
4961 false,
4962 true,
4963 true,
4964 false,
4965 true,
4966 false,
4967 false,
4968 true,
4969 true,
4970 false,
4971 true,
4972 false,
4973 true,
4974 };
4975 }
4976
4977 export fn zig_ret_vector_512_bool() Vector512Bool {
4978 return .{
4979 true,
4980 true,
4981 true,
4982 true,
4983 false,
4984 true,
4985 false,
4986 true,
4987 true,
4988 true,
4989 false,
4990 true,
4991 false,
4992 false,
4993 false,
4994 true,
4995 true,
4996 false,
4997 false,
4998 false,
4999 true,
5000 true,
5001 false,
5002 false,
5003 false,
5004 false,
5005 true,
5006 false,
5007 false,
5008 false,
5009 true,
5010 true,
5011 true,
5012 true,
5013 false,
5014 false,
5015 false,
5016 true,
5017 true,
5018 true,
5019 false,
5020 false,
5021 true,
5022 false,
5023 false,
5024 true,
5025 false,
5026 false,
5027 true,
5028 true,
5029 true,
5030 true,
5031 false,
5032 false,
5033 false,
5034 true,
5035 false,
5036 true,
5037 false,
5038 true,
5039 true,
5040 false,
5041 false,
5042 true,
5043 true,
5044 false,
5045 true,
5046 false,
5047 false,
5048 false,
5049 true,
5050 true,
5051 true,
5052 true,
5053 true,
5054 false,
5055 true,
5056 false,
5057 true,
5058 true,
5059 true,
5060 true,
5061 true,
5062 false,
5063 true,
5064 true,
5065 false,
5066 true,
5067 false,
5068 false,
5069 true,
5070 false,
5071 true,
5072 false,
5073 false,
5074 false,
5075 true,
5076 true,
5077 false,
5078 true,
5079 true,
5080 false,
5081 true,
5082 false,
5083 true,
5084 false,
5085 true,
5086 false,
5087 false,
5088 true,
5089 false,
5090 false,
5091 true,
5092 false,
5093 true,
5094 false,
5095 true,
5096 false,
5097 false,
5098 true,
5099 true,
5100 true,
5101 false,
5102 true,
5103 false,
5104 false,
5105 true,
5106 true,
5107 false,
5108 true,
5109 true,
5110 false,
5111 true,
5112 true,
5113 false,
5114 true,
5115 true,
5116 false,
5117 false,
5118 false,
5119 true,
5120 false,
5121 true,
5122 false,
5123 false,
5124 false,
5125 true,
5126 false,
5127 true,
5128 false,
5129 false,
5130 true,
5131 false,
5132 true,
5133 true,
5134 false,
5135 true,
5136 true,
5137 false,
5138 true,
5139 true,
5140 false,
5141 false,
5142 false,
5143 true,
5144 false,
5145 true,
5146 true,
5147 true,
5148 true,
5149 false,
5150 true,
5151 false,
5152 false,
5153 true,
5154 true,
5155 true,
5156 false,
5157 false,
5158 false,
5159 true,
5160 false,
5161 false,
5162 true,
5163 true,
5164 false,
5165 true,
5166 false,
5167 true,
5168 true,
5169 true,
5170 true,
5171 true,
5172 true,
5173 true,
5174 false,
5175 false,
5176 false,
5177 false,
5178 false,
5179 true,
5180 false,
5181 true,
5182 false,
5183 true,
5184 true,
5185 false,
5186 false,
5187 false,
5188 true,
5189 true,
5190 true,
5191 false,
5192 false,
5193 true,
5194 true,
5195 true,
5196 false,
5197 false,
5198 true,
5199 false,
5200 true,
5201 true,
5202 false,
5203 true,
5204 false,
5205 false,
5206 true,
5207 false,
5208 false,
5209 true,
5210 true,
5211 false,
5212 true,
5213 true,
5214 true,
5215 true,
5216 true,
5217 false,
5218 true,
5219 false,
5220 false,
5221 true,
5222 false,
5223 true,
5224 false,
5225 true,
5226 false,
5227 true,
5228 true,
5229 true,
5230 true,
5231 true,
5232 false,
5233 false,
5234 false,
5235 false,
5236 false,
5237 false,
5238 true,
5239 true,
5240 true,
5241 true,
5242 false,
5243 false,
5244 false,
5245 true,
5246 false,
5247 true,
5248 false,
5249 true,
5250 true,
5251 true,
5252 true,
5253 true,
5254 true,
5255 false,
5256 false,
5257 true,
5258 true,
5259 false,
5260 false,
5261 false,
5262 false,
5263 true,
5264 true,
5265 true,
5266 false,
5267 false,
5268 false,
5269 true,
5270 false,
5271 true,
5272 true,
5273 false,
5274 true,
5275 true,
5276 true,
5277 false,
5278 true,
5279 true,
5280 false,
5281 false,
5282 true,
5283 false,
5284 false,
5285 true,
5286 true,
5287 true,
5288 true,
5289 false,
5290 false,
5291 false,
5292 false,
5293 false,
5294 true,
5295 false,
5296 false,
5297 true,
5298 false,
5299 false,
5300 true,
5301 true,
5302 true,
5303 true,
5304 false,
5305 false,
5306 false,
5307 true,
5308 true,
5309 false,
5310 true,
5311 true,
5312 false,
5313 false,
5314 true,
5315 true,
5316 false,
5317 true,
5318 true,
5319 true,
5320 false,
5321 false,
5322 false,
5323 true,
5324 true,
5325 false,
5326 true,
5327 false,
5328 true,
5329 false,
5330 false,
5331 true,
5332 false,
5333 true,
5334 false,
5335 false,
5336 false,
5337 false,
5338 false,
5339 true,
5340 true,
5341 false,
5342 false,
5343 false,
5344 false,
5345 true,
5346 false,
5347 true,
5348 false,
5349 true,
5350 true,
5351 false,
5352 true,
5353 true,
5354 true,
5355 true,
5356 true,
5357 false,
5358 true,
5359 false,
5360 true,
5361 true,
5362 true,
5363 true,
5364 true,
5365 false,
5366 true,
5367 true,
5368 false,
5369 true,
5370 false,
5371 true,
5372 false,
5373 true,
5374 false,
5375 true,
5376 false,
5377 false,
5378 true,
5379 true,
5380 true,
5381 true,
5382 false,
5383 false,
5384 true,
5385 false,
5386 false,
5387 false,
5388 true,
5389 false,
5390 true,
5391 true,
5392 false,
5393 true,
5394 true,
5395 false,
5396 true,
5397 true,
5398 false,
5399 false,
5400 true,
5401 false,
5402 false,
5403 true,
5404 false,
5405 true,
5406 false,
5407 false,
5408 true,
5409 false,
5410 true,
5411 true,
5412 false,
5413 true,
5414 false,
5415 true,
5416 false,
5417 true,
5418 false,
5419 false,
5420 true,
5421 true,
5422 false,
5423 true,
5424 true,
5425 false,
5426 true,
5427 true,
5428 false,
5429 false,
5430 false,
5431 false,
5432 false,
5433 true,
5434 false,
5435 false,
5436 true,
5437 false,
5438 true,
5439 false,
5440 false,
5441 false,
5442 true,
5443 false,
5444 true,
5445 false,
5446 false,
5447 false,
5448 false,
5449 true,
5450 true,
5451 false,
5452 true,
5453 true,
5454 false,
5455 false,
5456 true,
5457 true,
5458 true,
5459 false,
5460 false,
5461 true,
5462 false,
5463 false,
5464 false,
5465 true,
5466 true,
5467 false,
5468 false,
5469 false,
5470 false,
5471 false,
5472 true,
5473 true,
5474 true,
5475 true,
5476 false,
5477 false,
5478 false,
5479 true,
5480 false,
5481 true,
5482 true,
5483 true,
5484 true,
5485 false,
5486 false,
5487 true,
5488 true,
5489 false,
5490 false,
5491 };
5492 }
5493 };
5494 }
5495}
5496
5497const Vector2 = extern struct { x: f32, y: f32 };
5498
5499extern fn c_ptr_size_float_struct(Vector2) void;
5500extern fn c_ret_ptr_size_float_struct() Vector2;
5501
5502test "C ABI pointer sized float struct" {
5503 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5504 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
5505 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5506 if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
5507 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5508
5509 c_ptr_size_float_struct(.{ .x = 1, .y = 2 });
5510
5511 const x = c_ret_ptr_size_float_struct();
5512 try expect(x.x == 3);
5513 try expect(x.y == 4);
5514}
5515
5516//=== Helpers for struct test ===//
5517pub inline fn expectOk(c_err: c_int) !void {
5518 if (c_err != 0) {
5519 std.debug.print("ABI mismatch on field v{d}.\n", .{c_err});
5520 return error.TestExpectedEqual;
5521 }
5522}
5523
5524/// Tests for Double + Char struct
5525const DC = extern struct { v1: f64, v2: u8 };
5526test "DC: Zig passes to C" {
5527 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5528 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
5529 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5530 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5531 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5532 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5533 try expectOk(c_assert_DC(.{ .v1 = -0.25, .v2 = 15 }));
5534}
5535test "DC: Zig returns to C" {
5536 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5537 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
5538 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5539 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5540 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5541 try expectOk(c_assert_ret_DC());
5542}
5543test "DC: C passes to Zig" {
5544 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5545 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
5546 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5547 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5548 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5549 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5550 try expectOk(c_send_DC());
5551}
5552test "DC: C returns to Zig" {
5553 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5554 if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
5555 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5556 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5557 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5558 try expectEqual(DC{ .v1 = -0.25, .v2 = 15 }, c_ret_DC());
5559}
5560
5561pub extern fn c_assert_DC(lv: DC) c_int;
5562pub extern fn c_assert_ret_DC() c_int;
5563pub extern fn c_send_DC() c_int;
5564pub extern fn c_ret_DC() DC;
5565pub export fn zig_assert_DC(lv: DC) c_int {
5566 var err: c_int = 0;
5567 if (lv.v1 != -0.25) err = 1;
5568 if (lv.v2 != 15) err = 2;
5569 if (err != 0) std.debug.print("Received {}", .{lv});
5570 return err;
5571}
5572pub export fn zig_ret_DC() DC {
5573 return .{ .v1 = -0.25, .v2 = 15 };
5574}
5575
5576/// Tests for Char + Float + FloatRect struct
5577const CFF = extern struct { v1: u8, v2: f32, v3: f32 };
5578
5579test "CFF: Zig passes to C" {
5580 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
5581 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5582 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5583 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5584 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5585 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5586 try expectOk(c_assert_CFF(.{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }));
5587}
5588test "CFF: Zig returns to C" {
5589 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5590 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5591 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5592 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5593 try expectOk(c_assert_ret_CFF());
5594}
5595test "CFF: C passes to Zig" {
5596 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
5597 if (builtin.cpu.arch.isRISCV() and builtin.mode != .Debug) return error.SkipZigTest;
5598 if (builtin.cpu.arch == .aarch64 and builtin.mode != .Debug) return error.SkipZigTest;
5599 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5600 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5601 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5602 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5603 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5604
5605 try expectOk(c_send_CFF());
5606}
5607test "CFF: C returns to Zig" {
5608 if (builtin.cpu.arch == .aarch64 and builtin.mode != .Debug) return error.SkipZigTest;
5609 if (builtin.cpu.arch.isRISCV() and builtin.mode != .Debug) return error.SkipZigTest;
5610 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5611 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5612 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5613 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5614 try expectEqual(CFF{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }, c_ret_CFF());
5615}
5616pub extern fn c_assert_CFF(lv: CFF) c_int;
5617pub extern fn c_assert_ret_CFF() c_int;
5618pub extern fn c_send_CFF() c_int;
5619pub extern fn c_ret_CFF() CFF;
5620pub export fn zig_assert_CFF(lv: CFF) c_int {
5621 var err: c_int = 0;
5622 if (lv.v1 != 39) err = 1;
5623 if (lv.v2 != 0.875) err = 2;
5624 if (lv.v3 != 1.0) err = 3;
5625 if (err != 0) std.debug.print("Received {}", .{lv});
5626 return err;
5627}
5628pub export fn zig_ret_CFF() CFF {
5629 return .{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 };
5630}
5631
5632/// Tests for Pointer + Double struct
5633const PD = extern struct { v1: ?*anyopaque, v2: f64 };
5634
5635test "PD: Zig passes to C" {
5636 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5637 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5638 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5639 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5640 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5641 try expectOk(c_assert_PD(.{ .v1 = null, .v2 = 0.5 }));
5642}
5643test "PD: Zig returns to C" {
5644 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5645 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5646 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5647 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5648 try expectOk(c_assert_ret_PD());
5649}
5650test "PD: C passes to Zig" {
5651 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5652 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5653 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5654 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5655 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5656 try expectOk(c_send_PD());
5657}
5658test "PD: C returns to Zig" {
5659 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5660 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5661 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5662 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5663 try expectEqual(PD{ .v1 = null, .v2 = 0.5 }, c_ret_PD());
5664}
5665pub extern fn c_assert_PD(lv: PD) c_int;
5666pub extern fn c_assert_ret_PD() c_int;
5667pub extern fn c_send_PD() c_int;
5668pub extern fn c_ret_PD() PD;
5669pub export fn zig_c_assert_PD(lv: PD) c_int {
5670 var err: c_int = 0;
5671 if (lv.v1 != null) err = 1;
5672 if (lv.v2 != 0.5) err = 2;
5673 if (err != 0) std.debug.print("Received {}", .{lv});
5674 return err;
5675}
5676pub export fn zig_ret_PD() PD {
5677 return .{ .v1 = null, .v2 = 0.5 };
5678}
5679pub export fn zig_assert_PD(lv: PD) c_int {
5680 var err: c_int = 0;
5681 if (lv.v1 != null) err = 1;
5682 if (lv.v2 != 0.5) err = 2;
5683 if (err != 0) std.debug.print("Received {}", .{lv});
5684 return err;
5685}
5686
5687const ByRef = extern struct {
5688 val: c_int,
5689 arr: [15]c_int,
5690};
5691extern fn c_modify_by_ref_param(ByRef) ByRef;
5692
5693test "C function modifies by ref param" {
5694 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5695 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5696 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5697
5698 const res = c_modify_by_ref_param(.{ .val = 1, .arr = undefined });
5699 try expect(res.val == 42);
5700}
5701
5702const ByVal = extern struct {
5703 origin: extern struct {
5704 x: c_ulong,
5705 y: c_ulong,
5706 z: c_ulong,
5707 },
5708 size: extern struct {
5709 width: c_ulong,
5710 height: c_ulong,
5711 depth: c_ulong,
5712 },
5713};
5714
5715extern fn c_func_ptr_byval(*anyopaque, *anyopaque, ByVal, c_ulong, *anyopaque, c_ulong) void;
5716test "C function that takes byval struct called via function pointer" {
5717 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5718 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5719 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5720 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5721 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5722
5723 var fn_ptr = &c_func_ptr_byval;
5724 _ = &fn_ptr;
5725 fn_ptr(
5726 @as(*anyopaque, @ptrFromInt(1)),
5727 @as(*anyopaque, @ptrFromInt(2)),
5728 ByVal{
5729 .origin = .{ .x = 9, .y = 10, .z = 11 },
5730 .size = .{ .width = 12, .height = 13, .depth = 14 },
5731 },
5732 @as(c_ulong, 3),
5733 @as(*anyopaque, @ptrFromInt(4)),
5734 @as(c_ulong, 5),
5735 );
5736}
5737
5738extern fn c_f16(f16) f16;
5739test "f16 bare" {
5740 if (!builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
5741
5742 const a = c_f16(12);
5743 try expect(a == 34);
5744}
5745
5746const f16_struct = extern struct {
5747 a: f16,
5748};
5749extern fn c_f16_struct(f16_struct) f16_struct;
5750test "f16 struct" {
5751 if (builtin.target.cpu.arch.isMIPS64()) return error.SkipZigTest;
5752 if (builtin.target.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5753 if (builtin.cpu.arch.isArm() and builtin.mode != .Debug) return error.SkipZigTest;
5754 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5755
5756 const a = c_f16_struct(.{ .a = 12 });
5757 try expect(a.a == 34);
5758}
5759
5760extern fn c_f80(f80) f80;
5761test "f80 bare" {
5762 if (!have_f80) return error.SkipZigTest;
5763
5764 const a = c_f80(12.34);
5765 try expect(@as(f64, @floatCast(a)) == 56.78);
5766}
5767
5768const f80_struct = extern struct {
5769 a: f80,
5770};
5771extern fn c_f80_struct(f80_struct) f80_struct;
5772test "f80 struct" {
5773 if (!have_f80) return error.SkipZigTest;
5774
5775 const a = c_f80_struct(.{ .a = 12.34 });
5776 try expect(@as(f64, @floatCast(a.a)) == 56.78);
5777}
5778
5779const f80_extra_struct = extern struct {
5780 a: f80,
5781 b: c_int,
5782};
5783extern fn c_f80_extra_struct(f80_extra_struct) f80_extra_struct;
5784test "f80 extra struct" {
5785 if (!have_f80) return error.SkipZigTest;
5786
5787 const a = c_f80_extra_struct(.{ .a = 12.34, .b = 42 });
5788 try expect(@as(f64, @floatCast(a.a)) == 56.78);
5789 try expect(a.b == 24);
5790}
5791
5792export fn zig_f128(x: f128) f128 {
5793 expect(x == 12) catch @panic("test failure");
5794 return 34;
5795}
5796extern fn c_f128(f128) f128;
5797test "f128 bare" {
5798 if (!have_f128) return error.SkipZigTest;
5799
5800 const a = c_f128(12.34);
5801 try expect(@as(f64, @floatCast(a)) == 56.78);
5802}
5803
5804const f128_struct = extern struct {
5805 a: f128,
5806};
5807export fn zig_f128_struct(a: f128_struct) f128_struct {
5808 expect(a.a == 12345) catch @panic("test failure");
5809 return .{ .a = 98765 };
5810}
5811extern fn c_f128_struct(f128_struct) f128_struct;
5812test "f128 struct" {
5813 if (!have_f128) return error.SkipZigTest;
5814
5815 const a = c_f128_struct(.{ .a = 12.34 });
5816 try expect(@as(f64, @floatCast(a.a)) == 56.78);
5817
5818 const b = c_f128_f128_struct(.{ .a = 12.34, .b = 87.65 });
5819 try expect(@as(f64, @floatCast(b.a)) == 56.78);
5820 try expect(@as(f64, @floatCast(b.b)) == 43.21);
5821}
5822
5823const f128_f128_struct = extern struct {
5824 a: f128,
5825 b: f128,
5826};
5827export fn zig_f128_f128_struct(a: f128_f128_struct) f128_f128_struct {
5828 expect(a.a == 13) catch @panic("test failure");
5829 expect(a.b == 57) catch @panic("test failure");
5830 return .{ .a = 24, .b = 68 };
5831}
5832extern fn c_f128_f128_struct(f128_f128_struct) f128_f128_struct;
5833test "f128 f128 struct" {
5834 if (!have_f128) return error.SkipZigTest;
5835
5836 const a = c_f128_struct(.{ .a = 12.34 });
5837 try expect(@as(f64, @floatCast(a.a)) == 56.78);
5838
5839 const b = c_f128_f128_struct(.{ .a = 12.34, .b = 87.65 });
5840 try expect(@as(f64, @floatCast(b.a)) == 56.78);
5841 try expect(@as(f64, @floatCast(b.b)) == 43.21);
5842}
5843
5844// The stdcall attribute on C functions is ignored when compiled on non-x86
5845const stdcall_callconv: std.builtin.CallingConvention = if (builtin.cpu.arch == .x86) .{ .x86_stdcall = .{} } else .c;
5846
5847extern fn stdcall_scalars(i8, i16, i32, f32, f64) callconv(stdcall_callconv) void;
5848test "Stdcall ABI scalars" {
5849 stdcall_scalars(1, 2, 3, 4.0, 5.0);
5850}
5851
5852const Coord2 = extern struct {
5853 x: i16,
5854 y: i16,
5855};
5856
5857extern fn stdcall_coord2(Coord2, Coord2, Coord2) callconv(stdcall_callconv) Coord2;
5858test "Stdcall ABI structs" {
5859 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5860 if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
5861 if (builtin.cpu.arch == .aarch64_be) return error.SkipZigTest;
5862 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5863 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5864 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5865
5866 const res = stdcall_coord2(
5867 .{ .x = 0x1111, .y = 0x2222 },
5868 .{ .x = 0x3333, .y = 0x4444 },
5869 .{ .x = 0x5555, .y = 0x6666 },
5870 );
5871 try expect(res.x == 123);
5872 try expect(res.y == 456);
5873}
5874
5875extern fn stdcall_big_union(BigUnion) callconv(stdcall_callconv) void;
5876test "Stdcall ABI big union" {
5877 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5878 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5879 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5880 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5881
5882 const x = BigUnion{
5883 .a = BigStruct{
5884 .a = 1,
5885 .b = 2,
5886 .c = 3,
5887 .d = 4,
5888 .e = 5,
5889 },
5890 };
5891 stdcall_big_union(x);
5892}
5893
5894extern fn c_explict_win64(ByRef) callconv(.{ .x86_64_win = .{} }) ByRef;
5895test "explicit SysV calling convention" {
5896 if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
5897
5898 const res = c_explict_win64(.{ .val = 1, .arr = undefined });
5899 try expect(res.val == 42);
5900}
5901
5902extern fn c_explict_sys_v(ByRef) callconv(.{ .x86_64_sysv = .{} }) ByRef;
5903test "explicit Win64 calling convention" {
5904 if (builtin.cpu.arch != .x86_64) return error.SkipZigTest;
5905
5906 const res = c_explict_sys_v(.{ .val = 1, .arr = undefined });
5907 try expect(res.val == 42);
5908}
5909
5910const byval_tail_callsite_attr = struct {
5911 const struct_Point = extern struct {
5912 x: f64,
5913 y: f64,
5914 };
5915 const struct_Size = extern struct {
5916 width: f64,
5917 height: f64,
5918 };
5919 const struct_Rect = extern struct {
5920 origin: struct_Point,
5921 size: struct_Size,
5922 };
5923
5924 const Point = extern struct {
5925 x: f64,
5926 y: f64,
5927 };
5928
5929 const Size = extern struct {
5930 width: f64,
5931 height: f64,
5932 };
5933
5934 const MyRect = extern struct {
5935 origin: Point,
5936 size: Size,
5937
5938 fn run(self: MyRect) f64 {
5939 return c_byval_tail_callsite_attr(cast(self));
5940 }
5941
5942 fn cast(self: MyRect) struct_Rect {
5943 return @bitCast(self);
5944 }
5945
5946 extern fn c_byval_tail_callsite_attr(struct_Rect) f64;
5947 };
5948};
5949
5950test "byval tail callsite attribute" {
5951 if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5952 if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5953 if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
5954 if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5955 if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5956
5957 // Originally reported at https://github.com/ziglang/zig/issues/16290
5958 // the bug was that the extern function had the byval attribute, but
5959 // zig did not put the byval attribute at the callsite. Some LLVM optimization
5960 // passes would then pass undefined for that parameter.
5961 var v: byval_tail_callsite_attr.MyRect = .{
5962 .origin = .{ .x = 1, .y = 2 },
5963 .size = .{ .width = 3, .height = 4 },
5964 };
5965 try expect(v.run() == 3.0);
5966}