From 4f921814c0a6555a61d9e0a92fcc6f30bc20e994 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Tue, 16 Jun 2026 01:43:20 -0400 Subject: [PATCH 1/4] main: handle more cli args for `zig test -ofmt=c` --- lib/zig.h | 26 +++++--- src/Compilation.zig | 109 ++++++++++++++++++--------------- src/codegen/c.zig | 5 +- src/link.zig | 4 +- src/link/Lld.zig | 40 ++++++------ src/link/MachO.zig | 14 ++--- src/link/MachO/relocatable.zig | 8 +-- src/main.zig | 98 ++++++++++++++++++++--------- 8 files changed, 184 insertions(+), 120 deletions(-) diff --git a/lib/zig.h b/lib/zig.h index 4f8b2da1d7de0ddcbd6d7df8c1b85d563349d7c1..34b56286a508b2707f4498f49612d9d625ee7c86 100644 --- a/lib/zig.h +++ b/lib/zig.h @@ -4557,9 +4557,12 @@ static inline void zig_msvc_atomic_store_i128(zig_i128 volatile* obj, zig_i128 a #include #endif +static inline void* zig_e_zig_windows_teb(void) zig_mangled(zig_e_zig_windows_teb, "zig_windows_teb"); +static inline void* zig_e_zig_windows_peb(void) zig_mangled(zig_e_zig_windows_peb, "zig_windows_peb"); + #if defined(zig_thumb) -static inline void* zig_windows_teb(void) { +static inline void* zig_e_zig_windows_teb(void) { void* teb = 0; #if defined(zig_msvc) teb = (void*)_MoveFromCoprocessor(15, 0, 13, 0, 2); @@ -4571,7 +4574,7 @@ static inline void* zig_windows_teb(void) { #elif defined(zig_aarch64) -static inline void* zig_windows_teb(void) { +static inline void* zig_e_zig_windows_teb(void) { void* teb = 0; #if defined(zig_msvc) teb = (void*)__readx18qword(0x0); @@ -4583,7 +4586,7 @@ static inline void* zig_windows_teb(void) { #elif defined(zig_x86_32) -static inline void* zig_windows_teb(void) { +static inline void* zig_e_zig_windows_teb(void) { void* teb = 0; #if defined(zig_msvc) teb = (void*)__readfsdword(0x18); @@ -4593,7 +4596,7 @@ static inline void* zig_windows_teb(void) { return teb; } -static inline void* zig_windows_peb(void) { +static inline void* zig_e_zig_windows_peb(void) { void* peb = 0; #if defined(zig_msvc) peb = (void*)__readfsdword(0x30); @@ -4605,7 +4608,7 @@ static inline void* zig_windows_peb(void) { #elif defined(zig_x86_64) -static inline void* zig_windows_teb(void) { +static inline void* zig_e_zig_windows_teb(void) { void* teb = 0; #if defined(zig_msvc) teb = (void*)__readgsqword(0x30); @@ -4615,7 +4618,7 @@ static inline void* zig_windows_teb(void) { return teb; } -static inline void* zig_windows_peb(void) { +static inline void* zig_e_zig_windows_peb(void) { void* peb = 0; #if defined(zig_msvc) peb = (void*)__readgsqword(0x60); @@ -4629,7 +4632,9 @@ static inline void* zig_windows_peb(void) { #if defined(zig_loongarch) -static inline void zig_loongarch_cpucfg(uint32_t word, uint32_t* result) { +static inline void zig_e_zig_loongarch_cpucfg(uint32_t word, uint32_t* result) zig_mangled(zig_e_zig_loongarch_cpucfg, "zig_loongarch_cpucfg"); + +static inline void zig_e_zig_loongarch_cpucfg(uint32_t word, uint32_t* result) { #if defined(zig_gnuc_asm) __asm__("cpucfg %[result], %[word]" : [result] "=r" (result) : [word] "r" (word)); #else @@ -4639,7 +4644,10 @@ static inline void zig_loongarch_cpucfg(uint32_t word, uint32_t* result) { #elif defined(zig_x86) && !defined(zig_x86_16) -static inline void zig_x86_cpuid(uint32_t leaf_id, uint32_t subid, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx) { +static inline void zig_e_zig_x86_cpuid(uint32_t leaf_id, uint32_t subid, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx) zig_mangled(zig_e_zig_x86_cpuid, "zig_x86_cpuid"); +static inline uint32_t zig_e_zig_x86_get_xcr0(void) zig_mangled(zig_e_zig_x86_get_xcr0, "zig_x86_get_xcr0"); + +static inline void zig_e_zig_x86_cpuid(uint32_t leaf_id, uint32_t subid, uint32_t* eax, uint32_t* ebx, uint32_t* ecx, uint32_t* edx) { #if defined(zig_msvc) int cpu_info[4]; __cpuidex(cpu_info, leaf_id, subid); @@ -4657,7 +4665,7 @@ static inline void zig_x86_cpuid(uint32_t leaf_id, uint32_t subid, uint32_t* eax #endif } -static inline uint32_t zig_x86_get_xcr0(void) { +static inline uint32_t zig_e_zig_x86_get_xcr0(void) { #if defined(zig_msvc) return (uint32_t)_xgetbv(0); #elif defined(zig_gnuc_asm) diff --git a/src/Compilation.zig b/src/Compilation.zig index c5d78866f8a97c69727b496abee4b035e5c14935..684889f2d021ea78587078d62468c85e1e4a971d 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -103,16 +103,12 @@ native_system_include_paths: []const []const u8, /// Corresponds to `-u ` for ELF/MachO and `/include:` for COFF/PE. force_undefined_symbols: std.array_hash_map.String(void), -c_object_table: std.array_hash_map.Auto(*CObject, void) = .empty, -win32_resource_table: if (dev.env.supports(.win32_resource)) std.array_hash_map.Auto(*Win32Resource, void) else struct { - pub fn keys(_: @This()) [0]void { - return .{}; - } - pub fn count(_: @This()) u0 { - return 0; - } +c_objects: std.ArrayList(*CObject) = .empty, +win32_resources: if (dev.env.supports(.win32_resource)) std.ArrayList(*Win32Resource) else struct { + items: [0]*struct {}, + pub const empty: @This() = .{ .items = .{} }; pub fn deinit(_: @This(), _: Allocator) void {} -} = .{}, +} = .empty, link_diags: link.Diags, link_queue: link.Queue = .empty, @@ -915,21 +911,6 @@ pub const CrtFile = struct { } }; -/// Supported languages for "zig clang -x ". -/// Loosely based on llvm-project/clang/include/clang/Driver/Types.def -pub const LangToExt = std.StaticStringMap(FileExt).initComptime(.{ - .{ "c", .c }, - .{ "c-header", .h }, - .{ "c++", .cpp }, - .{ "c++-header", .hpp }, - .{ "objective-c", .m }, - .{ "objective-c-header", .hm }, - .{ "objective-c++", .mm }, - .{ "objective-c++-header", .hmm }, - .{ "assembler", .assembly }, - .{ "assembler-with-cpp", .assembly_with_cpp }, -}); - /// For passing to a C compiler. pub const CSourceFile = struct { /// Many C compiler flags are determined by settings contained in the owning Module. @@ -2486,8 +2467,10 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, }; errdefer comp.destroy(); + if (target.ofmt == .c) return comp; + // Add a `CObject` for each `c_source_files`. - try comp.c_object_table.ensureTotalCapacity(gpa, options.c_source_files.len); + try comp.c_objects.ensureTotalCapacity(gpa, options.c_source_files.len); for (options.c_source_files) |c_source_file| { const c_object = try gpa.create(CObject); errdefer gpa.destroy(c_object); @@ -2496,7 +2479,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, .status = .{ .new = {} }, .src = c_source_file, }; - comp.c_object_table.putAssumeCapacityNoClobber(c_object, {}); + comp.c_objects.appendAssumeCapacity(c_object); } // Add a `Win32Resource` for each `rc_source_files` and one for `manifest_file`. @@ -2504,7 +2487,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, options.rc_source_files.len + @intFromBool(options.manifest_file != null); if (win32_resource_count > 0) { dev.check(.win32_resource); - try comp.win32_resource_table.ensureTotalCapacity(gpa, win32_resource_count); + try comp.win32_resources.ensureTotalCapacity(gpa, win32_resource_count); for (options.rc_source_files) |rc_source_file| { const win32_resource = try gpa.create(Win32Resource); errdefer gpa.destroy(win32_resource); @@ -2513,7 +2496,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, .status = .{ .new = {} }, .src = .{ .rc = rc_source_file }, }; - comp.win32_resource_table.putAssumeCapacityNoClobber(win32_resource, {}); + comp.win32_resources.appendAssumeCapacity(win32_resource); } if (options.manifest_file) |manifest_path| { @@ -2524,11 +2507,11 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, .status = .{ .new = {} }, .src = .{ .manifest = manifest_path }, }; - comp.win32_resource_table.putAssumeCapacityNoClobber(win32_resource, {}); + comp.win32_resources.appendAssumeCapacity(win32_resource); } } - if (comp.emit_bin != null and target.ofmt != .c) { + if (comp.emit_bin != null) { if (!comp.skip_linker_dependencies) { // If we need to build libc for the target, add work items for it. // We go through the work queue so that building can be done in parallel. @@ -2749,20 +2732,20 @@ pub fn destroy(comp: *Compilation) void { openbsd_file.deinit(gpa, io); } - for (comp.c_object_table.keys()) |key| { - key.destroy(gpa, io); + for (comp.c_objects.items) |c_object| { + c_object.destroy(gpa, io); } - comp.c_object_table.deinit(gpa); + comp.c_objects.deinit(gpa); for (comp.failed_c_objects.values()) |bundle| { bundle.destroy(gpa); } comp.failed_c_objects.deinit(gpa); - for (comp.win32_resource_table.keys()) |key| { - key.destroy(gpa, io); + for (comp.win32_resources.items) |win32_resource| { + win32_resource.destroy(gpa, io); } - comp.win32_resource_table.deinit(gpa); + comp.win32_resources.deinit(gpa); for (comp.failed_win32_resources.values()) |*value| { value.deinit(gpa); @@ -3016,8 +2999,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE // changes. For now, to avoid crashing the linker in this case, don't kick off C object // updates if we've done prelink already. https://codeberg.org/ziglang/zig/issues/32081 } else { - try comp.c_object_work_queue.ensureUnusedCapacity(gpa, comp.c_object_table.count()); - for (comp.c_object_table.keys()) |c_object| { + try comp.c_object_work_queue.ensureUnusedCapacity(gpa, comp.c_objects.items.len); + for (comp.c_objects.items) |c_object| { comp.c_object_work_queue.pushBackAssumeCapacity(c_object); try comp.appendFileSystemInput(try .fromUnresolved(arena, comp.dirs, &.{c_object.src.src_path})); } @@ -3032,8 +3015,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE // For compiling Win32 resources, we rely on the cache hash system to avoid duplicating work. // Add a Job for each Win32 resource file. - try comp.win32_resource_work_queue.ensureUnusedCapacity(gpa, comp.win32_resource_table.count()); - for (comp.win32_resource_table.keys()) |win32_resource| { + try comp.win32_resource_work_queue.ensureUnusedCapacity(gpa, comp.win32_resources.items.len); + for (comp.win32_resources.items) |win32_resource| { comp.win32_resource_work_queue.pushBackAssumeCapacity(win32_resource); switch (win32_resource.src) { .rc => |f| { @@ -3140,9 +3123,9 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE return; } - if (comp.zcu == null and comp.config.output_mode == .Obj and comp.c_object_table.count() == 1) { + if (comp.zcu == null and comp.config.output_mode == .Obj and comp.c_objects.items.len == 1) { // This is `zig build-obj foo.c`. We can emit asm and LLVM IR/bitcode. - const c_obj_path = comp.c_object_table.keys()[0].status.success.object_path; + const c_obj_path = comp.c_objects.items[0].status.success.object_path; if (comp.emit_asm) |path| try comp.emitFromCObject(arena, c_obj_path, ".s", path); if (comp.emit_llvm_ir) |path| try comp.emitFromCObject(arena, c_obj_path, ".ll", path); if (comp.emit_llvm_bc) |path| try comp.emitFromCObject(arena, c_obj_path, ".bc", path); @@ -3482,14 +3465,14 @@ fn addNonIncrementalStuffToCacheManifest( try link.hashInputs(man, comp.link_inputs); - for (comp.c_object_table.keys()) |key| { - _ = try man.addFile(key.src.src_path, null); - man.hash.addOptional(key.src.ext); - man.hash.addListOfBytes(key.src.extra_flags); + for (comp.c_objects.items) |c_object| { + _ = try man.addFile(c_object.src.src_path, null); + man.hash.addOptional(c_object.src.ext); + man.hash.addListOfBytes(c_object.src.extra_flags); } - for (comp.win32_resource_table.keys()) |key| { - switch (key.src) { + for (comp.win32_resources.items) |win32_resource| { + switch (win32_resource.src) { .rc => |rc_src| { _ = try man.addFile(rc_src.src_path, null); man.hash.addListOfBytes(rc_src.extra_flags); @@ -5592,9 +5575,10 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr c_source_basename[0 .. c_source_basename.len - fs.path.extension(c_source_basename).len]; const target = comp.getTarget(); + assert(target.ofmt != .c); const o_ext = target.ofmt.fileExt(target.cpu.arch); const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: { - var argv = std.array_list.Managed([]const u8).init(gpa); + var argv: std.array_list.Managed([]const u8) = .init(gpa); defer argv.deinit(); // In case we are doing passthrough mode, we need to detect -S and -emit-llvm. @@ -7057,6 +7041,33 @@ pub const FileExt = enum { .unknown => "", }; } + + /// The value accepted by "zig clang -x " and passed to "clang -x ". + pub fn toLang(ext: FileExt) ?[]const u8 { + return switch (ext) { + else => null, + .c => "c", + .h => "c-header", + .cpp => "c++", + .hpp => "c++-header", + .m => "objective-c", + .hm => "objective-c-header", + .mm => "objective-c++", + .hmm => "objective-c++-header", + .assembly => "assembler", + .assembly_with_cpp => "assembler-with-cpp", + }; + } + + /// Supported languages for "zig clang -x ". + /// Loosely based on llvm-project/clang/include/clang/Driver/Types.def + pub const from_lang = std.StaticStringMap(FileExt).initComptime(init: { + var init: []const struct { []const u8, FileExt } = &.{}; + for (std.enums.values(FileExt)) |file_ext| if (file_ext.toLang()) |lang| { + init = init ++ .{.{ lang, file_ext }}; + }; + break :init init; + }); }; pub fn hasObjectExt(filename: []const u8) bool { diff --git a/src/codegen/c.zig b/src/codegen/c.zig index 54b86f833191a93e6f059ccece94dbb951fa67c6..4a84fafc619dc1d9e772680f29052eef81dc9ddd 100644 --- a/src/codegen/c.zig +++ b/src/codegen/c.zig @@ -328,6 +328,9 @@ fn isReservedIdent(ident: []const u8) bool { return true; } + // zig.h + if (mem.startsWith(u8, ident, "zig_")) return true; + return reserved_idents.has(ident); } @@ -3755,7 +3758,7 @@ fn airCmpLteErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue { try f.writeCValue(w, local, .other); try w.writeAll(" = "); try f.writeCValue(w, operand, .other); - try w.print(" < sizeof({f}) / sizeof(*{0f});", .{fmtIdentSolo("zig_errorName")}); + try w.writeAll(" < sizeof(zig_errorName) / sizeof(*zig_errorName);"); try f.newline(); return local; } diff --git a/src/link.zig b/src/link.zig index 2b1fd8735bc5125d95f5e2135233a1a61ddd73d9..844eef3c407f3aecbc27b764a822808c5d1433e3 100644 --- a/src/link.zig +++ b/src/link.zig @@ -933,8 +933,8 @@ pub const File = struct { // Until then, we do `lld -r -o output.o input.o` even though the output is the same // as the input. For the preprocessing case (`zig cc -E -o foo`) we copy the file // to the final location. See also the corresponding TODO in Coff linking. - assert(comp.c_object_table.count() == 1); - const the_key = comp.c_object_table.keys()[0]; + assert(comp.c_objects.items.len == 1); + const the_key = comp.c_objects.items[0]; const cached_pp_file_path = the_key.status.success.object_path; Io.Dir.copyFile( cached_pp_file_path.root_dir.handle, diff --git a/src/link/Lld.zig b/src/link/Lld.zig index de9beee22a2d2259d2ba594e30a8637978b7a977..d84e3c1fe2a68042dd90ead613f9e9f17c80e740 100644 --- a/src/link/Lld.zig +++ b/src/link/Lld.zig @@ -313,14 +313,14 @@ fn linkAsArchive(lld: *Lld, arena: Allocator) !void { object_files.appendAssumeCapacity(try input.path().?.toStringZ(arena)); } - try object_files.ensureUnusedCapacity(arena, comp.c_object_table.count() + - comp.win32_resource_table.count() + 2); + try object_files.ensureUnusedCapacity(arena, comp.c_objects.items.len + + comp.win32_resources.items.len + 2); - for (comp.c_object_table.keys()) |key| { - object_files.appendAssumeCapacity(try key.status.success.object_path.toStringZ(arena)); + for (comp.c_objects.items) |c_object| { + object_files.appendAssumeCapacity(try c_object.status.success.object_path.toStringZ(arena)); } - for (comp.win32_resource_table.keys()) |key| { - object_files.appendAssumeCapacity(try arena.dupeSentinel(u8, key.status.success.res_path, 0)); + for (comp.win32_resources.items) |win32_resource| { + object_files.appendAssumeCapacity(try arena.dupeSentinel(u8, win32_resource.status.success.res_path, 0)); } if (zcu_obj_path) |p| object_files.appendAssumeCapacity(try p.toStringZ(arena)); if (compiler_rt_path) |p| object_files.appendAssumeCapacity(try p.toStringZ(arena)); @@ -395,8 +395,8 @@ fn coffLink(lld: *Lld, arena: Allocator) !void { const the_object_path = blk: { if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path; - if (comp.c_object_table.count() != 0) - break :blk comp.c_object_table.keys()[0].status.success.object_path; + if (comp.c_objects.items.len != 0) + break :blk comp.c_objects.items[0].status.success.object_path; if (zcu_obj_path) |p| break :blk p; @@ -546,12 +546,12 @@ fn coffLink(lld: *Lld, arena: Allocator) !void { }, }; - for (comp.c_object_table.keys()) |key| { - try argv.append(try key.status.success.object_path.toString(arena)); + for (comp.c_objects.items) |c_object| { + try argv.append(try c_object.status.success.object_path.toString(arena)); } - for (comp.win32_resource_table.keys()) |key| { - try argv.append(key.status.success.res_path); + for (comp.win32_resources.items) |win32_resource| { + try argv.append(win32_resource.status.success.res_path); } if (zcu_obj_path) |p| { @@ -805,8 +805,8 @@ fn elfLink(lld: *Lld, arena: Allocator) !void { const the_object_path = blk: { if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path; - if (comp.c_object_table.count() != 0) - break :blk comp.c_object_table.keys()[0].status.success.object_path; + if (comp.c_objects.items.len != 0) + break :blk comp.c_objects.items[0].status.success.object_path; if (zcu_obj_path) |p| break :blk p; @@ -1099,8 +1099,8 @@ fn elfLink(lld: *Lld, arena: Allocator) !void { whole_archive = false; } - for (comp.c_object_table.keys()) |key| { - try argv.append(try key.status.success.object_path.toString(arena)); + for (comp.c_objects.items) |c_object| { + try argv.append(try c_object.status.success.object_path.toString(arena)); } if (zcu_obj_path) |p| { @@ -1381,8 +1381,8 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void { const the_object_path = blk: { if (link.firstObjectInput(comp.link_inputs)) |obj| break :blk obj.path; - if (comp.c_object_table.count() != 0) - break :blk comp.c_object_table.keys()[0].status.success.object_path; + if (comp.c_objects.items.len != 0) + break :blk comp.c_objects.items[0].status.success.object_path; if (zcu_obj_path) |p| break :blk p; @@ -1566,8 +1566,8 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void { whole_archive = false; } - for (comp.c_object_table.keys()) |key| { - try argv.append(try key.status.success.object_path.toString(arena)); + for (comp.c_objects.items) |c_object| { + try argv.append(try c_object.status.success.object_path.toString(arena)); } if (zcu_obj_path) |p| { try argv.append(try p.toString(arena)); diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 8b045bf354aca5f5df2955307a1b67cc75f1a2fa..125db2983f2fa8a550b218d2d4be6d41153c1c8b 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -377,9 +377,9 @@ pub fn flush( // This is a set of object files emitted by clang in a single `build-exe` invocation. // For instance, the implicit `a.o` as compiled by `zig build-exe a.c` will end up // in this set. - try positionals.ensureUnusedCapacity(comp.c_object_table.keys().len); - for (comp.c_object_table.keys()) |key| { - positionals.appendAssumeCapacity(try link.openObjectInput(io, diags, key.status.success.object_path)); + try positionals.ensureUnusedCapacity(comp.c_objects.items.len); + for (comp.c_objects.items) |c_object| { + positionals.appendAssumeCapacity(try link.openObjectInput(io, diags, c_object.status.success.object_path)); } if (zcu_obj_path) |path| try positionals.append(try link.openObjectInput(io, diags, path)); @@ -657,8 +657,8 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void { .dso_exact => |dso_exact| try argv.appendSlice(&.{ "-l", dso_exact.name }), }; - for (comp.c_object_table.keys()) |key| { - try argv.append(try key.status.success.object_path.toString(arena)); + for (comp.c_objects.items) |c_object| { + try argv.append(try c_object.status.success.object_path.toString(arena)); } if (zcu_obj_path) |p| { @@ -749,8 +749,8 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void { .dso_exact => |dso_exact| try argv.appendSlice(&.{ "-l", dso_exact.name }), }; - for (comp.c_object_table.keys()) |key| { - try argv.append(try key.status.success.object_path.toString(arena)); + for (comp.c_objects.items) |c_object| { + try argv.append(try c_object.status.success.object_path.toString(arena)); } if (zcu_obj_path) |p| { diff --git a/src/link/MachO/relocatable.zig b/src/link/MachO/relocatable.zig index be36cfc045b7bb4abe4ff8fde43b62b7299511e6..b864ee66ca42394529dd6c58556e5cb10801e413 100644 --- a/src/link/MachO/relocatable.zig +++ b/src/link/MachO/relocatable.zig @@ -9,8 +9,8 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Pat try positionals.ensureUnusedCapacity(comp.link_inputs.len); positionals.appendSliceAssumeCapacity(comp.link_inputs); - for (comp.c_object_table.keys()) |key| { - try positionals.append(try link.openObjectInput(io, diags, key.status.success.object_path)); + for (comp.c_objects.items) |c_object| { + try positionals.append(try link.openObjectInput(io, diags, c_object.status.success.object_path)); } if (module_obj_path) |path| try positionals.append(try link.openObjectInput(io, diags, path)); @@ -86,8 +86,8 @@ pub fn flushStaticLib(macho_file: *MachO, comp: *Compilation, module_obj_path: ? try positionals.ensureUnusedCapacity(comp.link_inputs.len); positionals.appendSliceAssumeCapacity(comp.link_inputs); - for (comp.c_object_table.keys()) |key| { - try positionals.append(try link.openObjectInput(io, diags, key.status.success.object_path)); + for (comp.c_objects.items) |c_object| { + try positionals.append(try link.openObjectInput(io, diags, c_object.status.success.object_path)); } if (module_obj_path) |path| try positionals.append(try link.openObjectInput(io, diags, path)); diff --git a/src/main.zig b/src/main.zig index 44001796ff06962aae4168d2ae7ed7d241e84c42..6e47c30a30bb0e15d5f742c151a444a426ff91cd 100644 --- a/src/main.zig +++ b/src/main.zig @@ -887,6 +887,7 @@ const CliModule = struct { inherited: Package.Module.CreateOptions.Inherited, target_arch_os_abi: ?[]const u8, target_mcpu: ?[]const u8, + dynamic_linker: ?[]const u8, deps: []const Dep, resolved: ?*Package.Module, @@ -943,6 +944,7 @@ fn buildOutputType( var emit_implib_arg_provided = false; var target_arch_os_abi: ?[]const u8 = null; var target_mcpu: ?[]const u8 = null; + var dynamic_linker: ?[]const u8 = null; var emit_h: Emit = .no; var soname: SOName = undefined; var want_compiler_rt: ?bool = null; @@ -1059,7 +1061,6 @@ fn buildOutputType( // Populated just before the call to `createModule`. .dirs = undefined, .object_format = null, - .dynamic_linker = null, .modules = .empty, .opts = .{ .is_test = switch (arg_mode) { @@ -1179,6 +1180,7 @@ fn buildOutputType( &cc_argv, &target_arch_os_abi, &target_mcpu, + &dynamic_linker, &deps, &c_source_files_owner_index, &rc_source_files_owner_index, @@ -1397,9 +1399,9 @@ fn buildOutputType( } else if (mem.cutPrefix(u8, arg, "-O")) |rest| { mod_opts.optimize_mode = parseOptimizeMode(rest); } else if (mem.eql(u8, arg, "--dynamic-linker")) { - create_module.dynamic_linker = args_iter.nextOrFatal(); + dynamic_linker = args_iter.nextOrFatal(); } else if (mem.eql(u8, arg, "--no-dynamic-linker")) { - create_module.dynamic_linker = ""; + dynamic_linker = ""; } else if (mem.eql(u8, arg, "--sysroot")) { const next_arg = args_iter.nextOrFatal(); create_module.sysroot = next_arg; @@ -1846,7 +1848,7 @@ fn buildOutputType( const lang = if (rest.len == 0) args_iter.nextOrFatal() else rest; if (mem.eql(u8, lang, "none")) { file_ext = null; - } else if (Compilation.LangToExt.get(lang)) |got_ext| { + } else if (Compilation.FileExt.from_lang.get(lang)) |got_ext| { file_ext = got_ext; } else { fatal("language not recognized: {s}", .{lang}); @@ -1983,7 +1985,7 @@ fn buildOutputType( const lang = mem.sliceTo(it.only_arg, 0); if (mem.eql(u8, lang, "none")) { file_ext = null; - } else if (Compilation.LangToExt.get(lang)) |got_ext| { + } else if (Compilation.FileExt.from_lang.get(lang)) |got_ext| { file_ext = got_ext; } else { fatal("language not recognized: {q}", .{lang}); @@ -2610,12 +2612,11 @@ fn buildOutputType( mem.eql(u8, arg, "--dynamic-linker") or mem.eql(u8, arg, "-dynamic-linker")) { - create_module.dynamic_linker = linker_args_it.nextOrFatal(); - } else if (mem.eql(u8, arg, "-I") or - mem.eql(u8, arg, "--no-dynamic-linker") or + dynamic_linker = linker_args_it.nextOrFatal(); + } else if (mem.eql(u8, arg, "--no-dynamic-linker") or mem.eql(u8, arg, "-no-dynamic-linker")) { - create_module.dynamic_linker = ""; + dynamic_linker = ""; } else if (mem.eql(u8, arg, "-E") or mem.eql(u8, arg, "--export-dynamic") or mem.eql(u8, arg, "-export-dynamic")) @@ -3184,6 +3185,7 @@ fn buildOutputType( .inherited = mod_opts, .target_arch_os_abi = target_arch_os_abi, .target_mcpu = target_mcpu, + .dynamic_linker = dynamic_linker, .deps = try deps.toOwnedSlice(arena), .resolved = null, .c_source_files_start = c_source_files_owner_index, @@ -3842,10 +3844,59 @@ fn buildOutputType( if (test_exec_args.items.len == 0 and target.ofmt == .c and emit_bin_resolved != .no) { // Default to using `zig run` to execute the produced .c code from `zig test`. try test_exec_args.appendSlice(arena, &.{ self_exe_path, "run" }); - if (dirs.zig_lib.path) |p| { - try test_exec_args.appendSlice(arena, &.{ "-I", p }); + // Skip passing `-ofmt`, we want the default for the target, not `.c` anymore. + + var prev_has_cflags = false; + var prev_has_rcflags = false; + if (dirs.zig_lib.path) |zig_lib_path| { + try test_exec_args.appendSlice(arena, &.{ "-cflags", "-I", zig_lib_path, "--" }); + prev_has_cflags = true; + } + try test_exec_args.append(arena, null); + for (create_module.modules.keys(), create_module.modules.values()) |mod_name, mod| { + for (create_module.c_source_files.items[mod.c_source_files_start..mod.c_source_files_end]) |c_source_file| { + const cflags_len = c_source_file.extra_flags.len + c_source_file.cache_exempt_flags.len; + if (prev_has_cflags or cflags_len > 0) { + try test_exec_args.ensureUnusedCapacity(arena, 1 + cflags_len + 1); + test_exec_args.appendAssumeCapacity("-cflags"); + for (c_source_file.extra_flags) |extra_flag| test_exec_args.appendAssumeCapacity(extra_flag); + for (c_source_file.cache_exempt_flags) |cache_exempt_flag| test_exec_args.appendAssumeCapacity(cache_exempt_flag); + test_exec_args.appendAssumeCapacity("--"); + } + prev_has_cflags = cflags_len > 0; + if (c_source_file.ext) |ext| try test_exec_args.appendSlice(arena, &.{ "-x", ext.toLang() }); + try test_exec_args.append(arena, c_source_file.src_path); + if (c_source_file.ext) |_| try test_exec_args.appendSlice(arena, &.{ "-x", "none" }); + } + for (create_module.rc_source_files.items[mod.rc_source_files_start..mod.rc_source_files_end]) |rc_source_file| { + const rcflags_len = rc_source_file.extra_flags.len; + if (prev_has_rcflags or rcflags_len > 0) { + try test_exec_args.ensureUnusedCapacity(arena, 1 + rcflags_len + 1); + test_exec_args.appendAssumeCapacity("-rcflags"); + for (rc_source_file.extra_flags) |extra_flag| test_exec_args.appendAssumeCapacity(extra_flag); + test_exec_args.appendAssumeCapacity("--"); + } + prev_has_rcflags = rcflags_len > 0; + try test_exec_args.append(arena, rc_source_file.src_path); + } + if (mod.target_arch_os_abi) |triple| try test_exec_args.appendSlice(arena, &.{ "-target", triple }); + if (mod.target_mcpu) |mcpu| try test_exec_args.appendSlice(arena, &.{ "-mcpu", mcpu }); + if (mod.dynamic_linker) |dl| if (dl.len > 0) + try test_exec_args.appendSlice(arena, &.{ "--dynamic-linker", dl }) + else + try test_exec_args.append(arena, "--no-dynamic-linker"); + try test_exec_args.ensureUnusedCapacity(arena, mod.cc_argv.len); + for (mod.cc_argv) |cc_arg| test_exec_args.appendAssumeCapacity(cc_arg); + for (mod.deps) |dep| try test_exec_args.appendSlice(arena, &.{ + "--dep", + if (std.mem.eql(u8, dep.key, dep.value)) dep.value else try std.fmt.allocPrint(arena, "{s}={s}", .{ dep.key, dep.value }), + }); + try test_exec_args.append(arena, try std.fmt.allocPrint(arena, "-M{s}", .{mod_name})); } + try test_exec_args.ensureUnusedCapacity(arena, comp.global_cc_argv.len); + for (comp.global_cc_argv) |global_cc_arg| test_exec_args.appendAssumeCapacity(global_cc_arg); + if (create_module.resolved_options.link_libcpp) try test_exec_args.append(arena, "-lc++"); if (create_module.resolved_options.link_libc) { try test_exec_args.append(arena, "-lc"); } else if (target.os.tag == .windows) { @@ -3855,21 +3906,10 @@ fn buildOutputType( }); } - const first_cli_mod = create_module.modules.values()[0]; - if (first_cli_mod.target_arch_os_abi) |triple| { - try test_exec_args.appendSlice(arena, &.{ "-target", triple }); - } - if (first_cli_mod.target_mcpu) |mcpu| { - try test_exec_args.append(arena, try std.fmt.allocPrint(arena, "-mcpu={s}", .{mcpu})); - } - if (create_module.dynamic_linker) |dl| { - if (dl.len > 0) { - try test_exec_args.appendSlice(arena, &.{ "--dynamic-linker", dl }); - } else { - try test_exec_args.append(arena, "--no-dynamic-linker"); - } - } - try test_exec_args.append(arena, null); // placeholder for the path of the emitted C source file + try test_exec_args.ensureUnusedCapacity(arena, 2 * log_scopes.items.len + @intFromBool(verbose_link) + @intFromBool(verbose_cc)); + for (log_scopes.items) |log_scope| test_exec_args.appendSliceAssumeCapacity(&.{ "--debug-log", log_scope }); + if (verbose_link) test_exec_args.appendAssumeCapacity("--verbose-link"); + if (verbose_cc) test_exec_args.appendAssumeCapacity("--verbose-cc"); } try runOrTest( @@ -3898,7 +3938,6 @@ const CreateModule = struct { dirs: Compilation.Directories, modules: std.array_hash_map.String(CliModule), opts: Compilation.Config.Options, - dynamic_linker: ?[]const u8, object_format: ?[]const u8, /// undefined until createModule() for the root module is called. resolved_options: Compilation.Config, @@ -3960,7 +3999,7 @@ fn createModule( var target_parse_options: std.Target.Query.ParseOptions = .{ .arch_os_abi = cli_mod.target_arch_os_abi orelse "native", .cpu_features = cli_mod.target_mcpu, - .dynamic_linker = create_module.dynamic_linker, + .dynamic_linker = cli_mod.dynamic_linker, .object_format = create_module.object_format, }; @@ -7844,6 +7883,7 @@ fn handleModArg( cc_argv: *std.ArrayList([]const u8), target_arch_os_abi: *?[]const u8, target_mcpu: *?[]const u8, + dynamic_linker: *?[]const u8, deps: *std.ArrayList(CliModule.Dep), c_source_files_owner_index: *usize, rc_source_files_owner_index: *usize, @@ -7892,6 +7932,7 @@ fn handleModArg( .inherited = mod_opts.*, .target_arch_os_abi = target_arch_os_abi.*, .target_mcpu = target_mcpu.*, + .dynamic_linker = dynamic_linker.*, .deps = try deps.toOwnedSlice(arena), .resolved = null, .c_source_files_start = c_source_files_owner_index.*, @@ -7903,6 +7944,7 @@ fn handleModArg( mod_opts.* = .{}; target_arch_os_abi.* = null; target_mcpu.* = null; + dynamic_linker.* = null; c_source_files_owner_index.* = create_module.c_source_files.items.len; rc_source_files_owner_index.* = create_module.rc_source_files.items.len; } -- 2.54.0 From fba5c230f043a14e5b73c25add54cd1f2b15ba40 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Sun, 14 Jun 2026 03:58:43 -0400 Subject: [PATCH 2/4] x86_64: implement win64 abi for more vector types --- src/codegen/llvm/FuncGen.zig | 56 +- src/codegen/x86_64/CodeGen.zig | 1722 ++- src/codegen/x86_64/abi.zig | 204 +- test/c_abi/cfuncs.c | 17117 +++++++++++++++++++++------ test/c_abi/main.zig | 19737 ++++++++++++++++++++++++------- test/tests.zig | 31 + 6 files changed, 30308 insertions(+), 8559 deletions(-) diff --git a/src/codegen/llvm/FuncGen.zig b/src/codegen/llvm/FuncGen.zig index 787ab1a7f0ab9b8fd96a9607a2e19eadb8bba997..d7ae7ea93bb4d6fde7d37a1c753470eb6e0392da 100644 --- a/src/codegen/llvm/FuncGen.zig +++ b/src/codegen/llvm/FuncGen.zig @@ -6789,22 +6789,29 @@ const ParamTypeIterator = struct { return .abi_sized_int; } }, - .win_i128 => { + .sse, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => { it.zig_index += 1; it.llvm_index += 1; - return .byref; + return .byval; }, + .sseup, .x87, .x87up, .none, .float, .float_combine => unreachable, .memory => { it.zig_index += 1; it.llvm_index += 1; return .byref_mut; }, - .sse => { + .win_i128 => { it.zig_index += 1; it.llvm_index += 1; - return .byval; + return .byref; }, - else => unreachable, } } @@ -6867,9 +6874,13 @@ const ParamTypeIterator = struct { .none => break, .memory => unreachable, // handled above .win_i128 => unreachable, // windows only - .integer_per_element => { - @panic("TODO"); - }, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => unreachable, // vectors already handled by `isScalar` above } offset += 8; } @@ -6912,7 +6923,7 @@ pub fn iterateParamTypes(object: *Object, fn_info: InternPool.Key.FuncType) Para .fn_info = fn_info, .zig_index = 0, .llvm_index = 0, - .types_len = 0, + .types_len = undefined, .types_buffer = undefined, .offsets_buffer = undefined, .byval_attr = false, @@ -6979,6 +6990,7 @@ fn firstParamSRetX86Fastcall(zcu: *Zcu, ty: Type) bool { } fn firstParamSRetSystemV(ty: Type, zcu: *Zcu, target: *const std.Target) bool { + if (isScalar(zcu, ty)) return false; const class = x86_64_abi.classifySystemV(ty, zcu, target, .ret); if (class[0] == .memory) return true; if (class[0] == .x87 and class[2] != .none) return true; @@ -7078,10 +7090,23 @@ fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Err return o.builder.intType(@intCast(return_type.abiSize(zcu) * 8)); } }, + .sse, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => return o.lowerType(return_type), + .sseup, + .x87, + .x87up, + .none, + .float, + .float_combine, + => unreachable, .win_i128 => return o.builder.vectorType(.normal, 2, .i64), .memory => return .void, - .sse => return o.lowerType(return_type), - else => unreachable, } } @@ -7129,8 +7154,15 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E }, .x87up => continue, .none => break, - .memory, .integer_per_element => return .void, + .memory => return .void, .win_i128 => unreachable, // windows only + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => unreachable, // vectors already handled by `isScalar` above } } const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer}); diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig index 27b3d501b3f9eb7a1be5e7d2926838d0ee3c9578..8d8b22da7bd1b79fa24e53a39963b69d188fa07e 100644 --- a/src/codegen/x86_64/CodeGen.zig +++ b/src/codegen/x86_64/CodeGen.zig @@ -169,6 +169,11 @@ const MaskInfo = packed struct { scalar: Memory.Size, }; +const ArgsInfo = struct { + info: packed struct { reg_index: u3, frame_off: i29 }, + frame_index: FrameIndex, +}; + pub const MCValue = union(enum) { /// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc. /// TODO Look into deleting this tag and using `dead` instead, since every use @@ -220,8 +225,16 @@ pub const MCValue = union(enum) { lea_lazy_sym: link.File.LazySymbol, load_extern_func: Mir.NullTerminatedString, lea_extern_func: Mir.NullTerminatedString, - /// Supports integer_per_element abi - elementwise_args: packed struct { regs: u3, frame_off: i29, frame_index: FrameIndex }, + /// Supports `integer_per_element` abi + elementwise_gpr: ArgsInfo, + /// Supports `sse_per_element` abi + elementwise_sse: ArgsInfo, + /// Supports `sse_per_xword` abi + xwordwise_sse: ArgsInfo, + /// Supports `sse_per_yword` abi + ywordwise_sse: ArgsInfo, + /// Supports `sse_per_zword` abi + zwordwise_sse: ArgsInfo, /// This indicates that we have already allocated a frame index for this instruction, /// but it has not been spilled there yet in the current control flow. /// Payload is a frame index. @@ -248,7 +261,11 @@ pub const MCValue = union(enum) { .lea_lazy_sym, .lea_extern_func, .load_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => false, @@ -369,7 +386,11 @@ pub const MCValue = union(enum) { .lea_uav, .lea_lazy_sym, .lea_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // not in memory @@ -406,7 +427,11 @@ pub const MCValue = union(enum) { .load_uav, .load_lazy_sym, .load_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // not dereferenceable @@ -428,7 +453,11 @@ pub const MCValue = union(enum) { .unreach, .dead, .undef, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // not valid @@ -482,7 +511,11 @@ pub const MCValue = union(enum) { .register_mask, .indirect_load_frame, .lea_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .lea_nav, .lea_uav, @@ -560,8 +593,20 @@ pub const MCValue = union(enum) { .lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }), .load_extern_func => |pl| try w.print("[extern:{d}]", .{@intFromEnum(pl)}), .lea_extern_func => |pl| try w.print("extern:{d}", .{@intFromEnum(pl)}), - .elementwise_args => |pl| try w.print("elementwise:{d}:[{f} + 0x{x}]", .{ - pl.regs, pl.frame_index, pl.frame_off, + .elementwise_gpr => |pl| try w.print("elementwise:gpr{d}:[{f} + 0x{x}]", .{ + pl.info.reg_index, pl.frame_index, pl.info.frame_off, + }), + .elementwise_sse => |pl| try w.print("elementwise:sse{d}:[{f} + 0x{x}]", .{ + pl.info.reg_index, pl.frame_index, pl.info.frame_off, + }), + .xwordwise_sse => |pl| try w.print("xwordwise:sse{d}:[{f} + 0x{x}]", .{ + pl.info.reg_index, pl.frame_index, pl.info.frame_off, + }), + .ywordwise_sse => |pl| try w.print("ywordwise:sse{d}:[{f} + 0x{x}]", .{ + pl.info.reg_index, pl.frame_index, pl.info.frame_off, + }), + .zwordwise_sse => |pl| try w.print("zwordwise:sse{d}:[{f} + 0x{x}]", .{ + pl.info.reg_index, pl.frame_index, pl.info.frame_off, }), .reserved_frame => |pl| try w.print("(dead:{f})", .{pl}), .air_ref => |pl| try w.print("(air:0x{x})", .{@intFromEnum(pl)}), @@ -595,7 +640,11 @@ const InstTracking = struct { .lea_extern_func, => result, .dead, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, @@ -707,7 +756,11 @@ const InstTracking = struct { .register_overflow, .register_mask, .indirect, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .air_ref, => unreachable, } @@ -789,19 +842,24 @@ const InstTracking = struct { // Disable death. var found_reg = false; - var remaining_reg: Register = .none; + var remaining_regs: [4]Register = undefined; + var remaining_regs_len: usize = 0; for (tracking.getRegs()) |tracked_reg| if (tracked_reg.id() == reg.id()) { assert(!found_reg); found_reg = true; } else { - assert(remaining_reg == .none); - remaining_reg = tracked_reg; + remaining_regs[remaining_regs_len] = tracked_reg; + remaining_regs_len += 1; }; assert(found_reg); if (tracking.long == .none) tracking.long = tracking.short; - tracking.short = switch (remaining_reg) { - .none => .{ .dead = function.scope_generation }, - else => .{ .register = remaining_reg }, + tracking.short = switch (remaining_regs_len) { + 0 => .{ .dead = function.scope_generation }, + 1 => .{ .register = remaining_regs[0] }, + 2 => .{ .register_pair = remaining_regs[0..2].* }, + 3 => .{ .register_triple = remaining_regs[0..3].* }, + 4 => .{ .register_quadruple = remaining_regs[0..4].* }, + else => unreachable, }; // Perform side-effects of freeValue manually. @@ -89204,7 +89262,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { var ops = try cg.tempsFromOperands(inst, .{un_op}); while (try ops[0].toBase(false, cg)) {} try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{ - .size = cg.memSize(eu_err_ty), + .size = cg.memSize(eu_err_ty, .general_purpose), .disp = eu_err_off, }), .u(0)); const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); @@ -89220,7 +89278,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { var ops = try cg.tempsFromOperands(inst, .{un_op}); while (try ops[0].toBase(false, cg)) {} try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{ - .size = cg.memSize(eu_err_ty), + .size = cg.memSize(eu_err_ty, .general_purpose), .disp = eu_err_off, }), .u(0)); const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); @@ -89236,11 +89294,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { var ops = try cg.tempsFromOperands(inst, .{un_op}); try ops[0].toOffset(eu_err_off, cg); while (try ops[0].toLea(cg)) {} - try cg.asmMemoryImmediate( - .{ ._, .cmp }, - try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), - .u(0), - ); + try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.deref().mem(cg, .{ + .size = cg.memSize(eu_err_ty, .general_purpose), + }), .u(0)); const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); try is_err.finish(inst, &.{un_op}, &ops, cg); }, @@ -89254,11 +89310,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { var ops = try cg.tempsFromOperands(inst, .{un_op}); try ops[0].toOffset(eu_err_off, cg); while (try ops[0].toLea(cg)) {} - try cg.asmMemoryImmediate( - .{ ._, .cmp }, - try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), - .u(0), - ); + try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.deref().mem(cg, .{ + .size = cg.memSize(eu_err_ty, .general_purpose), + }), .u(0)); const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, @@ -174463,7 +174517,11 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, // not a valid pointer .immediate, @@ -174516,7 +174574,11 @@ fn store( .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, // not a valid pointer .immediate, @@ -174566,7 +174628,11 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: .lea_uav, .lea_lazy_sym, .lea_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // unmodifiable destination @@ -175256,7 +175322,11 @@ fn genBinOpMir( .lea_lazy_sym, .lea_extern_func, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // unmodifiable destination @@ -175293,7 +175363,11 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, .register, @@ -175465,7 +175539,11 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, @@ -175569,7 +175647,11 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, @@ -175683,120 +175765,233 @@ fn genBinOpMir( } } -fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void { - const zcu = self.pt.zcu; - const arg_index = for (self.args, 0..) |arg, arg_index| { +fn airArg(cg: *CodeGen, inst: Air.Inst.Index) !void { + const zcu = cg.pt.zcu; + const arg_index = for (cg.args, 0..) |arg, arg_index| { if (arg != .none) break arg_index; } else unreachable; - const src_mcv = self.args[arg_index]; - self.args = self.args[arg_index + 1 ..]; - const result: MCValue = if (self.mod.strip and self.liveness.isUnused(inst)) .unreach else result: { - const arg_ty = self.typeOfIndex(inst); + const src_mcv = cg.args[arg_index]; + cg.args = cg.args[arg_index + 1 ..]; + const result: MCValue = if (cg.mod.strip and cg.liveness.isUnused(inst)) .unreach else result: { + const arg_ty = cg.typeOfIndex(inst); switch (src_mcv) { .register, .register_pair, .load_frame => { - for (src_mcv.getRegs()) |reg| self.register_manager.getRegAssumeFree(reg, inst); + for (src_mcv.getRegs()) |reg| cg.register_manager.getRegAssumeFree(reg, inst); break :result src_mcv; }, .indirect => |reg_off| { - self.register_manager.getRegAssumeFree(reg_off.reg, null); - const dst_mcv = try self.allocRegOrMem(inst, false); - try self.genCopy(arg_ty, dst_mcv, src_mcv, .{}); + cg.register_manager.getRegAssumeFree(reg_off.reg, null); + const dst_mcv = try cg.allocRegOrMem(inst, false); + try cg.genCopy(arg_ty, dst_mcv, src_mcv, .{}); break :result dst_mcv; }, .indirect_load_frame => |frame_addr| { - const dst_mcv = try self.allocRegOrMem(inst, false); - const ptr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg); - defer self.register_manager.unlockReg(ptr_lock); - try self.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{}); - try self.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{}); + const dst_mcv = try cg.allocRegOrMem(inst, false); + const ptr_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const ptr_lock = cg.register_manager.lockRegAssumeUnused(ptr_reg); + defer cg.register_manager.unlockReg(ptr_lock); + try cg.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{}); + try cg.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{}); break :result dst_mcv; }, - .elementwise_args => |regs_frame_addr| { - try self.spillEflagsIfOccupied(); + .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { + const fn_info = zcu.typeToFunc(cg.fn_type).?; + const elem_ty = arg_ty.childType(zcu); + const elem_rc: Register.Class, const param_regs = switch (src_mcv) { + else => unreachable, + .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, + .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, + }; + const len = arg_ty.vectorLen(zcu); + const param_reg_len: u31 = + @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); - const fn_info = zcu.typeToFunc(self.fn_type).?; - const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc); - var prev_reg: Register = undefined; - for ( - param_int_regs[param_int_regs.len - regs_frame_addr.regs ..], - 0.., - ) |dst_reg, elem_index| { - assert(self.register_manager.isRegFree(dst_reg)); - if (elem_index > 0) { - try self.asmRegisterImmediate(.{ ._l, .sh }, dst_reg.to8(), .u(elem_index)); - try self.asmRegisterRegister( - .{ ._, .@"or" }, - dst_reg.to8(), - prev_reg.to8(), + const elem_size = cg.memSize(elem_ty, .general_purpose); + const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8); + const strat = if (elem_ty.toIntern() == .bool_type) strat: { + try cg.spillEflagsIfOccupied(); + break :strat undefined; + } else try cg.moveStrategy(elem_ty, elem_rc, true); + + const dst_mcv = try cg.allocRegOrMem(inst, false); + { + var prev_reg: Register = undefined; + for ( + param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len], + 0.., + ) |src_reg, elem_index| { + assert(cg.register_manager.isRegFree(src_reg)); + if (elem_ty.toIntern() == .bool_type) { + if (elem_index > 0) { + try cg.asmRegisterImmediate( + .{ ._l, .sh }, + src_reg.to8(), + .u(elem_index), + ); + try cg.asmRegisterRegister( + .{ ._, .@"or" }, + src_reg.to8(), + prev_reg.to8(), + ); + } + prev_reg = src_reg; + } else try strat.write(cg, try dst_mcv.mem(cg, .{ + .size = elem_size, + .disp = @intCast(elem_abi_size * elem_index), + }), src_reg.toSize(elem_size, cg.target)); + } + if (elem_ty.toIntern() == .bool_type) { + if (param_reg_len > 0) { + const prev_lock = cg.register_manager.lockRegAssumeUnused(prev_reg); + defer cg.register_manager.unlockReg(prev_lock); + try cg.asmMemoryRegister( + .{ ._, .mov }, + try dst_mcv.mem(cg, .{ .size = .byte }), + prev_reg.to8(), + ); + } + const clear_len = arg_ty.abiSize(zcu) - @intFromBool(param_reg_len > 0); + if (clear_len > 0) try cg.genInlineMemset( + dst_mcv.address().offset(@intFromBool(param_reg_len > 0)), + .{ .immediate = 0 }, + .{ .immediate = clear_len }, + .{}, + ); + } + } + if (len - param_reg_len > 0) { + const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg); + defer cg.register_manager.unlockReg(index_lock); + try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len)); + + const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len); + if (elem_ty.toIntern() == .bool_type) { + try cg.asmMemoryImmediate(.{ ._, .cmp }, .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = .byte, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }, Immediate.u(0)); + const unset = try cg.asmJccReloc(.e, undefined); + try cg.asmMemoryRegister( + .{ ._s, .bt }, + try dst_mcv.mem(cg, .{ .size = .dword }), + index_reg.to32(), ); + cg.performReloc(unset); + } else { + const elem_reg = + try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc)); + const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg); + defer cg.register_manager.unlockReg(elem_lock); + + try strat.read(cg, elem_reg.toSize(elem_size, cg.target), .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }); + try strat.write(cg, try dst_mcv.mem(cg, .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .fromFactor(@intCast(elem_abi_size)), + }), elem_reg.toSize(elem_size, cg.target)); + } + if (cg.hasFeature(.slow_incdec)) { + try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); + } else { + try cg.asmRegister(.{ ._c, .in }, index_reg.to32()); } - prev_reg = dst_reg; + try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len)); + _ = try cg.asmJccReloc(.b, loop); } - const prev_lock = if (regs_frame_addr.regs > 0) - self.register_manager.lockRegAssumeUnused(prev_reg) - else - null; - defer if (prev_lock) |lock| self.register_manager.unlockReg(lock); + break :result dst_mcv; + }, + .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { + const fn_info = zcu.typeToFunc(cg.fn_type).?; + const elem_size: Memory.Size, const elem_ty: Type = switch (src_mcv) { + else => unreachable, + .xwordwise_sse => .{ .xword, .vector_16_u8 }, + .ywordwise_sse => .{ .yword, .vector_32_u8 }, + .zwordwise_sse => .{ .zword, .vector_64_u8 }, + }; + const elem_abi_size: u31 = @intCast(@divExact(elem_size.bitSize(cg.target), 8)); + const strat = try cg.moveStrategy(elem_ty, .sse, true); + + const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const len = @divExact(arg_ty.abiSize(zcu), elem_abi_size); + const param_gpr_len: u31 = + @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); + + const part_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse); + const part_lock = cg.register_manager.lockRegAssumeUnused(part_reg); + defer cg.register_manager.unlockReg(part_lock); + const part_alias = part_reg.toSize(elem_size, cg.target); - const dst_mcv = try self.allocRegOrMem(inst, false); - if (regs_frame_addr.regs > 0) try self.asmMemoryRegister( - .{ ._, .mov }, - try dst_mcv.mem(self, .{ .size = .byte }), - prev_reg.to8(), - ); - try self.genInlineMemset( - dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)), - .{ .immediate = 0 }, - .{ .immediate = arg_ty.abiSize(zcu) - @intFromBool(regs_frame_addr.regs > 0) }, - .{}, - ); + const dst_mcv = try cg.allocRegOrMem(inst, false); - const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const index_lock = self.register_manager.lockRegAssumeUnused(index_reg); - defer self.register_manager.unlockReg(index_lock); + var arg_offset: u31 = 0; + for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |src_reg| { + try strat.read(cg, part_alias, .{ + .base = .{ .reg = src_reg }, + .mod = .{ .rm = .{ .size = elem_size } }, + }); + try strat.write(cg, try dst_mcv.mem(cg, .{ + .size = elem_size, + .disp = arg_offset, + }), part_alias); + arg_offset += elem_abi_size; + } + + if (len - param_gpr_len > 0) { + const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg); + defer cg.register_manager.unlockReg(index_lock); + try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(8 * param_gpr_len)); - try self.asmRegisterImmediate( - .{ ._, .mov }, - index_reg.to32(), - .u(regs_frame_addr.regs), - ); - const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len); - try self.asmMemoryImmediate(.{ ._, .cmp }, .{ - .base = .{ .frame = regs_frame_addr.frame_index }, - .mod = .{ .rm = .{ - .size = .byte, - .index = index_reg.to64(), - .scale = .@"8", - .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8, - } }, - }, Immediate.u(0)); - const unset = try self.asmJccReloc(.e, undefined); - try self.asmMemoryRegister( - .{ ._s, .bt }, - try dst_mcv.mem(self, .{ .size = .dword }), - index_reg.to32(), - ); - self.performReloc(unset); - if (self.hasFeature(.slow_incdec)) { - try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); - } else { - try self.asmRegister(.{ ._c, .in }, index_reg.to32()); + const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len); + { + const ptr_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const ptr_lock = cg.register_manager.lockRegAssumeUnused(ptr_reg); + defer cg.register_manager.unlockReg(ptr_lock); + + try cg.asmRegisterMemory(.{ ._, .mov }, ptr_reg.to64(), .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = .ptr, + .index = index_reg.to64(), + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_gpr_len, + } }, + }); + try strat.read(cg, part_alias, .{ + .base = .{ .reg = ptr_reg }, + .mod = .{ .rm = .{ .size = elem_size } }, + }); + try strat.write(cg, try dst_mcv.mem(cg, .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .fromFactor(@intCast(@divExact(elem_abi_size, 8))), + }), part_alias); + } + try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(8)); + try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(8 * len)); + _ = try cg.asmJccReloc(.b, loop); } - try self.asmRegisterImmediate( - .{ ._, .cmp }, - index_reg.to32(), - .u(arg_ty.vectorLen(zcu)), - ); - _ = try self.asmJccReloc(.b, loop); break :result dst_mcv; }, - else => return self.fail("TODO implement arg for {f}", .{src_mcv}), + else => return cg.fail("TODO implement arg for {f}", .{src_mcv}), } }; - return self.finishAir(inst, result, .{ .none, .none, .none }); + return cg.finishAir(inst, result, .{ .none, .none, .none }); } fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue) !void { @@ -175804,7 +175999,17 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue _ = switch (air_tag) { else => unreachable, .arg, .dbg_var_val, .dbg_arg_inline => switch (mcv) { - .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable, + .none, + .unreach, + .dead, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, + .reserved_frame, + .air_ref, + => unreachable, .immediate => |imm| if (std.math.cast(u32, imm)) |small| try cg.addInst(.{ .tag = .pseudo, .ops = switch (air_tag) { @@ -175852,7 +176057,17 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue }, .dbg_var_ptr => switch (mcv) { else => unreachable, - .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable, + .none, + .unreach, + .dead, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, + .reserved_frame, + .air_ref, + => unreachable, .lea_frame => |frame_addr| try cg.addInst(.{ .tag = .pseudo, .ops = .pseudo_dbg_var_m, @@ -175910,10 +176125,10 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue }; } -fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void { - if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{}); +fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void { + if (modifier == .always_tail) return cg.fail("TODO implement tail calls for x86_64", .{}); - const call = self.air.unwrapCall(inst); + const call = cg.air.unwrapCall(inst); const arg_refs = call.args; const ExpectedContents = extern struct { @@ -175921,28 +176136,28 @@ fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier vals: [32][@sizeOf(MCValue)]u8 align(@alignOf(MCValue)), }; var bfa_buf: [1]ExpectedContents = undefined; - var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa); + var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), cg.gpa); const allocator = bfa.allocator(); const arg_tys = try allocator.alloc(Type, arg_refs.len); defer allocator.free(arg_tys); - for (arg_tys, arg_refs) |*arg_ty, arg_ref| arg_ty.* = self.typeOf(arg_ref); + for (arg_tys, arg_refs) |*arg_ty, arg_ref| arg_ty.* = cg.typeOf(arg_ref); const arg_vals = try allocator.alloc(MCValue, arg_refs.len); defer allocator.free(arg_vals); for (arg_vals, arg_refs) |*arg_val, arg_ref| arg_val.* = .{ .air_ref = arg_ref }; - const ret = try self.genCall(.{ .air = call.callee }, arg_tys, arg_vals, opts); + const ret = try cg.genCall(.{ .air = call.callee }, arg_tys, arg_vals, opts); - var bt = self.liveness.iterateBigTomb(inst); - try self.feed(&bt, call.callee); - for (arg_refs) |arg_ref| try self.feed(&bt, arg_ref); + var bt = cg.liveness.iterateBigTomb(inst); + try cg.feed(&bt, call.callee); + for (arg_refs) |arg_ref| try cg.feed(&bt, arg_ref); - const result = if (self.liveness.isUnused(inst)) .unreach else ret; - return self.finishAirResult(inst, result); + const result = if (cg.liveness.isUnused(inst)) .unreach else ret; + return cg.finishAirResult(inst, result); } -fn genCall(self: *CodeGen, info: union(enum) { +fn genCall(cg: *CodeGen, info: union(enum) { air: Air.Inst.Ref, extern_func: struct { return_type: InternPool.Index, @@ -175950,13 +176165,13 @@ fn genCall(self: *CodeGen, info: union(enum) { sym: []const u8, }, }, arg_types: []const Type, args: []const MCValue, opts: CopyOptions) !MCValue { - const pt = self.pt; + const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; const fn_ty = switch (info) { .air => |callee| fn_info: { - const callee_ty = self.typeOf(callee); + const callee_ty = cg.typeOf(callee); break :fn_info switch (callee_ty.zigTypeTag(zcu)) { .@"fn" => callee_ty, .pointer => callee_ty.childType(zcu), @@ -175966,7 +176181,7 @@ fn genCall(self: *CodeGen, info: union(enum) { .extern_func => |extern_func| try pt.funcType(.{ .param_types = extern_func.param_types, .return_type = extern_func.return_type, - .cc = self.target.cCallingConvention().?, + .cc = cg.target.cCallingConvention().?, }), }; const fn_info = zcu.typeToFunc(fn_ty).?; @@ -175977,7 +176192,7 @@ fn genCall(self: *CodeGen, info: union(enum) { reg_locks: [32][@sizeOf(?RegisterLock)]u8 align(@alignOf(?RegisterLock)), }; var bfa_buf: ExpectedContents = undefined; - var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa); + var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), cg.gpa); const allocator = bfa.allocator(); const var_args = try allocator.alloc(Type, args.len - fn_info.param_types.len); @@ -175990,10 +176205,10 @@ fn genCall(self: *CodeGen, info: union(enum) { var reg_locks: std.array_list.Managed(?RegisterLock) = .init(allocator); defer reg_locks.deinit(); try reg_locks.ensureTotalCapacity(16); - defer for (reg_locks.items) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock); + defer for (reg_locks.items) |reg_lock| if (reg_lock) |lock| cg.register_manager.unlockReg(lock); - var call_info = try self.resolveCallingConventionValues(fn_info, var_args, .call_frame); - defer call_info.deinit(self); + var call_info = try cg.resolveCallingConventionValues(fn_info, var_args, .call_frame); + defer call_info.deinit(cg); // We need a properly aligned and sized call frame to be able to call this function. { @@ -176001,7 +176216,7 @@ fn genCall(self: *CodeGen, info: union(enum) { .size = call_info.stack_byte_count, .alignment = call_info.stack_align, }); - const frame_allocs_slice = self.frame_allocs.slice(); + const frame_allocs_slice = cg.frame_allocs.slice(); const stack_frame_size = &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)]; stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size); @@ -176010,22 +176225,22 @@ fn genCall(self: *CodeGen, info: union(enum) { stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align); } - try self.spillEflagsIfOccupied(); - try self.spillCallerPreservedRegs(fn_info.cc, call_info.err_ret_trace_reg); + try cg.spillEflagsIfOccupied(); + try cg.spillCallerPreservedRegs(fn_info.cc, call_info.err_ret_trace_reg); // set stack arguments first because this can clobber registers // also clobber spill arguments as we go switch (call_info.return_value.long) { .none, .unreach => {}, - .indirect => |reg_off| try self.register_manager.getReg(reg_off.reg, null), + .indirect => |reg_off| try cg.register_manager.getReg(reg_off.reg, null), else => unreachable, } for (call_info.args, arg_types, args, frame_indices, 0..) |dst_arg, arg_ty, src_arg, *frame_index, arg_i| switch (dst_arg) { .none => {}, .register => |reg| { - try self.register_manager.getReg(reg, null); - try reg_locks.append(self.register_manager.lockReg(reg)); + try cg.register_manager.getReg(reg, null); + try reg_locks.append(cg.register_manager.lockReg(reg)); if (fn_info.is_var_args and fn_info.cc == .x86_64_win and @@ -176034,88 +176249,166 @@ fn genCall(self: *CodeGen, info: union(enum) { { // Floating point arguments must be duplicated into the equivalent integer registers on this ABI const int_reg = abi.Win64.c_abi_int_param_regs[arg_i]; - try reg_locks.append(self.register_manager.lockReg(int_reg)); + try reg_locks.append(cg.register_manager.lockReg(int_reg)); } }, .register_pair => |regs| { - for (regs) |reg| try self.register_manager.getReg(reg, null); - try reg_locks.appendSlice(&self.register_manager.lockRegs(2, regs)); + for (regs) |reg| try cg.register_manager.getReg(reg, null); + try reg_locks.appendSlice(&cg.register_manager.lockRegs(2, regs)); }, .indirect => |reg_off| { - frame_index.* = try self.allocFrameIndex(.initType(arg_ty, zcu)); - try self.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); - try self.register_manager.getReg(reg_off.reg, null); - try reg_locks.append(self.register_manager.lockReg(reg_off.reg)); + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + try cg.register_manager.getReg(reg_off.reg, null); + try reg_locks.append(cg.register_manager.lockReg(reg_off.reg)); + }, + .indirect_load_frame => |frame_addr| { + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + try cg.genSetMem( + .{ .frame = frame_addr.index }, + frame_addr.off, + .usize, + .{ .lea_frame = .{ .index = frame_index.* } }, + opts, + ); }, .load_frame => { - try self.genCopy(arg_ty, dst_arg, src_arg, opts); - try self.freeValue(src_arg, .{}); + try cg.genCopy(arg_ty, dst_arg, src_arg, opts); + try cg.freeValue(src_arg, .{}); }, - .elementwise_args => |regs_frame_addr| { - const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const index_lock = self.register_manager.lockRegAssumeUnused(index_reg); - defer self.register_manager.unlockReg(index_lock); - - const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{ - .base = .{ .reg = try self.copyToTmpRegister(.usize, switch (src_arg) { + .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { + const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ + .base = .{ .reg = try cg.copyToTmpRegister(.usize, switch (src_arg) { else => src_arg, - .air_ref => |src_ref| try self.resolveInst(src_ref), + .air_ref => |src_ref| try cg.resolveInst(src_ref), }.address()) }, .mod = .{ .rm = .{ .size = .dword } }, }; const src_lock = switch (src_mem.base) { - .reg => |src_reg| self.register_manager.lockReg(src_reg), + .reg => |src_reg| cg.register_manager.lockReg(src_reg), else => null, }; - defer if (src_lock) |lock| self.register_manager.unlockReg(lock); + defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); - try self.asmRegisterImmediate( - .{ ._, .mov }, - index_reg.to32(), - .u(regs_frame_addr.regs), - ); - const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len); - try self.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32()); - try self.asmSetccMemory(.c, .{ - .base = .{ .frame = regs_frame_addr.frame_index }, - .mod = .{ .rm = .{ - .size = .byte, - .index = index_reg.to64(), - .scale = .@"8", - .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8, - } }, - }); - if (self.hasFeature(.slow_incdec)) { - try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); - } else { - try self.asmRegister(.{ ._c, .in }, index_reg.to32()); + const elem_rc: Register.Class, const param_regs = switch (dst_arg) { + else => unreachable, + .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, + .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, + }; + const len = arg_ty.vectorLen(zcu); + const param_reg_len: u31 = + @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); + + if (len - param_reg_len > 0) { + const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg); + defer cg.register_manager.unlockReg(index_lock); + try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len)); + + const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len); + const elem_ty = arg_ty.childType(zcu); + if (elem_ty.toIntern() == .bool_type) { + try cg.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32()); + try cg.asmSetccMemory(.c, .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = .byte, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }); + } else { + const elem_reg = + try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc)); + const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg); + defer cg.register_manager.unlockReg(elem_lock); + const elem_size = cg.memSize(elem_ty, .general_purpose); + const elem_alias = elem_reg.toSize(elem_size, cg.target); + + const strat = try cg.moveStrategy(elem_ty, elem_rc, true); + assert(src_mem.mod.rm.index == .none and src_mem.mod.rm.scale == .@"1"); + try strat.read(cg, elem_alias, .{ + .base = src_mem.base, + .mod = .{ .rm = .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .fromFactor(@intCast(@divExact(elem_size.bitSize(cg.target), 8))), + .disp = src_mem.mod.rm.disp, + } }, + }); + try strat.write(cg, .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }, elem_alias); + } + if (cg.hasFeature(.slow_incdec)) { + try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); + } else { + try cg.asmRegister(.{ ._c, .in }, index_reg.to32()); + } + try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len)); + _ = try cg.asmJccReloc(.b, loop); } - try self.asmRegisterImmediate( - .{ ._, .cmp }, - index_reg.to32(), - .u(arg_ty.vectorLen(zcu)), + + for (param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len]) |dst_reg| { + try cg.register_manager.getReg(dst_reg, null); + try reg_locks.append(cg.register_manager.lockReg(dst_reg)); + } + }, + .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { + const elem_size: u31 = switch (dst_arg) { + else => unreachable, + .xwordwise_sse => 16, + .ywordwise_sse => 32, + .zwordwise_sse => 64, + }; + const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const arg_size: u31 = @intCast(arg_ty.abiSize(zcu)); + const len = @divExact(arg_size, elem_size); + const param_gpr_len: u31 = + @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); + + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + + var frame_offset: i32 = regs_frame_addr.info.frame_off; + var arg_offset = elem_size * param_gpr_len; + while (arg_size - arg_offset != 0) : ({ + frame_offset += 8; + arg_offset += elem_size; + }) try cg.genSetMem( + .{ .frame = regs_frame_addr.frame_index }, + frame_offset, + .usize, + .{ .lea_frame = .{ .index = frame_index.*, .off = arg_offset } }, + opts, ); - _ = try self.asmJccReloc(.b, loop); - const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc); - for (param_int_regs[param_int_regs.len - regs_frame_addr.regs ..]) |dst_reg| { - try self.register_manager.getReg(dst_reg, null); - try reg_locks.append(self.register_manager.lockReg(dst_reg)); + for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { + try cg.register_manager.getReg(dst_reg, null); + try reg_locks.append(cg.register_manager.lockReg(dst_reg)); } }, else => unreachable, }; if (call_info.err_ret_trace_reg != .none) { - if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { + if (cg.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { if (switch (err_ret_trace.short) { .register => |reg| call_info.err_ret_trace_reg != reg, else => true, }) { - try self.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index); - try reg_locks.append(self.register_manager.lockReg(call_info.err_ret_trace_reg)); + try cg.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index); + try reg_locks.append(cg.register_manager.lockReg(call_info.err_ret_trace_reg)); - try self.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, .{}); + try cg.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, opts); err_ret_trace.trackMaterialize(err_ret_trace_index, .{ .long = err_ret_trace.long, .short = .{ .register = call_info.err_ret_trace_reg }, @@ -176129,31 +176422,31 @@ fn genCall(self: *CodeGen, info: union(enum) { .none, .unreach => {}, .indirect => |reg_off| { const ret_ty: Type = .fromInterned(fn_info.return_type); - const frame_index = try self.allocFrameIndex(.initSpill(ret_ty, zcu)); - try self.genSetReg(reg_off.reg, .usize, .{ + const frame_index = try cg.allocFrameIndex(.initSpill(ret_ty, zcu)); + try cg.genSetReg(reg_off.reg, .usize, .{ .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, - }, .{}); + }, opts); call_info.return_value.short = .{ .load_frame = .{ .index = frame_index } }; - try reg_locks.append(self.register_manager.lockReg(reg_off.reg)); + try reg_locks.append(cg.register_manager.lockReg(reg_off.reg)); }, else => unreachable, } for (call_info.args, arg_types, args, frame_indices, 0..) |dst_arg, arg_ty, src_arg, frame_index, arg_i| switch (dst_arg) { - .none, .load_frame => {}, + .none, .load_frame, .indirect_load_frame => {}, .register => |dst_reg| switch (fn_info.cc) { - else => try self.genSetReg(registerAlias( + else => try cg.genSetReg(registerAlias( dst_reg, @intCast(arg_ty.abiSize(zcu)), ), arg_ty, src_arg, opts), .x86_64_sysv, .x86_64_win => { - const promoted_ty = self.promoteInt(arg_ty); - const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(zcu)); - const dst_alias = registerAlias(dst_reg, promoted_abi_size); - try self.genSetReg(dst_alias, promoted_ty, src_arg, opts); + const promoted_ty = cg.promoteInt(arg_ty); + const promoted_unaligned_size: u32 = @intCast(cg.unalignedSize(promoted_ty)); + const dst_alias = registerAlias(dst_reg, promoted_unaligned_size); + try cg.genSetReg(dst_alias, promoted_ty, src_arg, opts); if (promoted_ty.toIntern() != arg_ty.toIntern()) - try self.truncateRegister(arg_ty, dst_alias); + try cg.truncateRegister(arg_ty, dst_alias); if (fn_info.is_var_args and fn_info.cc == .x86_64_win and @@ -176161,47 +176454,90 @@ fn genCall(self: *CodeGen, info: union(enum) { arg_i < abi.Win64.c_abi_int_param_regs.len) { const int_dst_reg = abi.Win64.c_abi_int_param_regs[arg_i]; - const int_dst_alias = registerAlias(int_dst_reg, promoted_abi_size); - try self.genSetReg(int_dst_alias, promoted_ty, .{ .register = dst_alias }, opts); + const int_dst_alias = registerAlias(int_dst_reg, promoted_unaligned_size); + try cg.genSetReg(int_dst_alias, promoted_ty, .{ .register = dst_alias }, opts); } }, }, - .register_pair => try self.genCopy(arg_ty, dst_arg, src_arg, opts), - .indirect => |reg_off| try self.genSetReg(reg_off.reg, .usize, .{ + .register_pair => try cg.genCopy(arg_ty, dst_arg, src_arg, opts), + .indirect => |reg_off| try cg.genSetReg(reg_off.reg, .usize, .{ .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, - }, .{}), - .elementwise_args => |regs_frame_addr| { - const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{ - .base = .{ .reg = try self.copyToTmpRegister( + }, opts), + .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { + const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ + .base = .{ .reg = try cg.copyToTmpRegister( .usize, switch (src_arg) { else => src_arg, - .air_ref => |src_ref| try self.resolveInst(src_ref), + .air_ref => |src_ref| try cg.resolveInst(src_ref), }.address(), ) }, .mod = .{ .rm = .{ .size = .dword } }, }; const src_lock = switch (src_mem.base) { - .reg => |src_reg| self.register_manager.lockReg(src_reg), + .reg => |src_reg| cg.register_manager.lockReg(src_reg), else => null, }; - defer if (src_lock) |lock| self.register_manager.unlockReg(lock); + defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); - const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const elem_rc: Register.Class, const param_regs = switch (dst_arg) { + else => unreachable, + .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, + .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, + }; + const len = arg_ty.vectorLen(zcu); + const elem_ty = arg_ty.childType(zcu); + const elem_size = cg.memSize(elem_ty, .general_purpose); + const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8); + const param_reg_len: u31 = + @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); + const strat = if (elem_ty.toIntern() == .bool_type) strat: { + try cg.spillEflagsIfOccupied(); + break :strat undefined; + } else try cg.moveStrategy(elem_ty, elem_rc, true); for ( - param_int_regs[param_int_regs.len - regs_frame_addr.regs ..], + param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len], 0.., - ) |dst_reg, elem_index| { - try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); - try self.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index)); - try self.asmSetccRegister(.c, dst_reg.to8()); + ) |dst_reg, elem_index| if (elem_ty.toIntern() == .bool_type) { + try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); + try cg.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index)); + try cg.asmSetccRegister(.c, dst_reg.to8()); + } else try strat.read(cg, dst_reg.toSize(elem_size, cg.target), .{ + .base = src_mem.base, + .mod = .{ .rm = .{ + .size = elem_size, + .disp = src_mem.mod.rm.disp + @as(u31, @intCast(elem_abi_size * elem_index)), + } }, + }); + }, + .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { + const elem_size: u31 = switch (dst_arg) { + else => unreachable, + .xwordwise_sse => 16, + .ywordwise_sse => 32, + .zwordwise_sse => 64, + }; + const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const len = @divExact(arg_ty.abiSize(zcu), elem_size); + const param_gpr_len: u31 = + @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); + + var arg_offset: u31 = 0; + for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { + try cg.genSetReg( + dst_reg, + .usize, + .{ .lea_frame = .{ .index = frame_index, .off = arg_offset } }, + opts, + ); + arg_offset += elem_size; } }, else => unreachable, }; if (fn_info.is_var_args and fn_info.cc == .x86_64_sysv) - try self.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count)); + try cg.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count)); // Due to incremental compilation, how function calls are generated depends // on linking. @@ -176216,16 +176552,16 @@ fn genCall(self: *CodeGen, info: union(enum) { } else func_key, }) { else => unreachable, - .func => |func| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = func.owner_nav } }), - .@"extern" => |@"extern"| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = @"extern".owner_nav } }), + .func => |func| try cg.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = func.owner_nav } }), + .@"extern" => |@"extern"| try cg.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = @"extern".owner_nav } }), } } else { - assert(self.typeOf(callee).zigTypeTag(zcu) == .pointer); + assert(cg.typeOf(callee).zigTypeTag(zcu) == .pointer); const scratch_reg = abi.getCAbiLinkerScratchReg(fn_info.cc); - try self.genSetReg(scratch_reg, .usize, .{ .air_ref = callee }, .{}); - try self.asmRegister(.{ ._, .call }, scratch_reg); + try cg.genSetReg(scratch_reg, .usize, .{ .air_ref = callee }, opts); + try cg.asmRegister(.{ ._, .call }, scratch_reg); }, - .extern_func => |extern_func| try self.asmImmediate(.{ ._, .call }, .{ .extern_func = try self.addString(extern_func.sym) }), + .extern_func => |extern_func| try cg.asmImmediate(.{ ._, .call }, .{ .extern_func = try cg.addString(extern_func.sym) }), } return call_info.return_value.short; } @@ -176291,7 +176627,11 @@ fn airRetLoad(self: *CodeGen, inst: Air.Inst.Index) !void { const ptr_ty = self.typeOf(un_op); switch (self.ret_mcv.short) { .none => {}, - .register, .register_pair => try self.load(self.ret_mcv.short, ptr_ty, ptr), + .register, + .register_pair, + .register_triple, + .register_quadruple, + => try self.load(self.ret_mcv.short, ptr_ty, ptr), .indirect => |reg_off| try self.genSetReg(reg_off.reg, ptr_ty, ptr, .{}), else => unreachable, } @@ -176504,17 +176844,13 @@ fn isErrPtr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv: defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock); const err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu)); - try self.asmMemoryImmediate( - .{ ._, .cmp }, - .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = self.memSize(.anyerror), - .disp = err_off, - } }, - }, - .u(0), - ); + try self.asmMemoryImmediate(.{ ._, .cmp }, .{ + .base = .{ .reg = ptr_reg }, + .mod = .{ .rm = .{ + .size = self.memSize(.anyerror, .general_purpose), + .disp = err_off, + } }, + }, .u(0)); if (maybe_inst) |inst| self.eflags_inst = inst; return MCValue{ .eflags = .a }; @@ -178302,7 +178638,11 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .lea_uav, .lea_lazy_sym, .lea_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // unmodifiable destination @@ -178313,7 +178653,11 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .dead, .undef, .register_overflow, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, .immediate, @@ -178414,9 +178758,9 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C for ([_]bool{ false, true }) |emit_hazard| { var hazard_count: u3 = 0; - var part_disp: i32 = 0; + var part_disp: u31 = 0; for (dst_regs, try self.splitType(dst_regs.len, ty), 0..) |dst_reg, dst_ty, part_i| { - defer part_disp += @intCast(dst_ty.abiSize(pt.zcu)); + defer part_disp += @intCast(self.unalignedSize(dst_ty)); const is_hazard = if (src_mcv.getReg()) |src_reg| dst_reg.id() == src_reg.id() else if (src_info) |info| @@ -178483,36 +178827,40 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C } fn genSetReg( - self: *CodeGen, + cg: *CodeGen, dst_reg: Register, ty: Type, src_mcv: MCValue, opts: CopyOptions, ) InnerError!void { - const pt = self.pt; + const pt = cg.pt; const zcu = pt.zcu; const abi_size: u32 = @intCast(ty.abiSize(zcu)); - const dst_alias = registerAlias(dst_reg, abi_size); - if (ty.bitSize(zcu) > dst_alias.size().bitSize(self.target)) - return self.fail("genSetReg called with a value larger than dst_reg", .{}); + const dst_alias = registerAlias(dst_reg, @intCast(cg.unalignedSize(ty))); + if (ty.bitSize(zcu) > dst_alias.size().bitSize(cg.target)) + return cg.fail("genSetReg called with a value larger than dst_reg", .{}); switch (src_mcv) { .none, .unreach, .dead, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, .undef => if (opts.safety) switch (dst_reg.class()) { .general_purpose, .gphi => switch (abi_size) { - 1 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to8(), .u(0xaa)), - 2 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to16(), .u(0xaaaa)), - 3...4 => try self.asmRegisterImmediate( + 1 => try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to8(), .u(0xaa)), + 2 => try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to16(), .u(0xaaaa)), + 3...4 => try cg.asmRegisterImmediate( .{ ._, .mov }, dst_reg.to32(), .s(@as(i32, @bitCast(@as(u32, 0xaaaaaaaa)))), ), - 5...8 => try self.asmRegisterImmediate( + 5...8 => try cg.asmRegisterImmediate( .{ ._, .mov }, dst_reg.to64(), .u(0xaaaaaaaaaaaaaaaa), @@ -178521,36 +178869,36 @@ fn genSetReg( }, .segment, .mmx, .sse => { const full_ty = try pt.vectorType(.{ - .len = self.vectorSize(.float), + .len = cg.vectorSize(.float), .child = .u8_type, }); - try self.genSetReg(dst_reg, full_ty, try self.lowerValue( + try cg.genSetReg(dst_reg, full_ty, try cg.lowerValue( try pt.aggregateSplatValue(full_ty, try pt.intValue(.u8, 0xaa)), ), opts); }, - .x87 => try self.genSetReg(dst_reg, .f80, try self.lowerValue( + .x87 => try cg.genSetReg(dst_reg, .f80, try cg.lowerValue( try pt.floatValue(.f80, @as(f80, @bitCast(@as(u80, 0xaaaaaaaaaaaaaaaaaaaa)))), ), opts), .ip, .cr, .dr => unreachable, }, - .eflags => |cc| try self.asmSetccRegister(cc, dst_reg.to8()), + .eflags => |cc| try cg.asmSetccRegister(cc, dst_reg.to8()), .immediate => |imm| { if (imm == 0) { // 32-bit moves zero-extend to 64-bit, so xoring the 32-bit // register is the fastest way to zero a register. - try self.spillEflagsIfOccupied(); - try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); + try cg.spillEflagsIfOccupied(); + try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); } else if (abi_size > 4 and std.math.cast(u32, imm) != null) { // 32-bit moves zero-extend to 64-bit. - try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to32(), .u(imm)); + try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to32(), .u(imm)); } else if (abi_size <= 4 and @as(i64, @bitCast(imm)) < 0) { - try self.asmRegisterImmediate( + try cg.asmRegisterImmediate( .{ ._, .mov }, dst_alias, .s(@intCast(@as(i64, @bitCast(imm)))), ); } else { - try self.asmRegisterImmediate( + try cg.asmRegisterImmediate( .{ ._, .mov }, dst_alias, .u(imm), @@ -178559,44 +178907,44 @@ fn genSetReg( }, .register => |src_reg| if (dst_reg.id() != src_reg.id()) switch (dst_reg.class()) { .general_purpose => switch (src_reg.class()) { - .general_purpose => try self.asmRegisterRegister( + .general_purpose => try cg.asmRegisterRegister( .{ ._, .mov }, dst_alias, - registerAlias(src_reg, abi_size), + registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), ), - .gphi => if (dst_reg.isClass(.gphi)) try self.asmRegisterRegister( + .gphi => if (dst_reg.isClass(.gphi)) try cg.asmRegisterRegister( .{ ._, .mov }, dst_alias, - registerAlias(src_reg, abi_size), + registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), ) else { - const src_lock = self.register_manager.lockReg(src_reg); - defer if (src_lock) |lock| self.register_manager.unlockReg(lock); - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi); + const src_lock = cg.register_manager.lockReg(src_reg); + defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); + const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gphi); - try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg); - try self.asmRegisterRegister(.{ ._, .mov }, dst_alias, tmp_reg.to8()); + try cg.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg); + try cg.asmRegisterRegister(.{ ._, .mov }, dst_alias, tmp_reg.to8()); }, - .segment => try self.asmRegisterRegister( + .segment => try cg.asmRegisterRegister( .{ ._, .mov }, dst_alias, src_reg, ), .x87, .mmx, .ip, .cr, .dr => unreachable, - .sse => if (self.hasFeature(.sse2)) try self.asmRegisterRegister( + .sse => if (cg.hasFeature(.sse2)) try cg.asmRegisterRegister( switch (abi_size) { - 1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov }, - 5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov }, + 1...4 => if (cg.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov }, + 5...8 => if (cg.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov }, else => unreachable, }, - registerAlias(dst_reg, @max(abi_size, 4)), + registerAlias(dst_reg, @intCast(@max(cg.unalignedSize(ty), 4))), src_reg.to128(), ) else { const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4)); - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = frame_size, .alignment = .fromNonzeroByteUnits(frame_size), })); - try self.asmMemoryRegister(switch (frame_size) { + try cg.asmMemoryRegister(switch (frame_size) { 4 => .{ ._ss, .mov }, 8 => .{ ._ps, .movl }, 16 => .{ ._ps, .mov }, @@ -178605,82 +178953,85 @@ fn genSetReg( .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(frame_size) } }, }, src_reg.to128()); - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ + try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(abi_size) } }, }); }, }, .gphi => switch (src_reg.class()) { - .general_purpose => if (src_reg.isClass(.gphi)) try self.asmRegisterRegister( + .general_purpose => if (src_reg.isClass(.gphi)) try cg.asmRegisterRegister( .{ ._, .mov }, dst_alias, - registerAlias(src_reg, abi_size), + registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), ) else { - const dst_lock = self.register_manager.lockReg(dst_reg); - defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi); + const dst_lock = cg.register_manager.lockReg(dst_reg); + defer if (dst_lock) |lock| cg.register_manager.unlockReg(lock); + const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gphi); - try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg.to8()); - try self.asmRegisterRegister(.{ ._, .mov }, dst_reg, tmp_reg.to8()); + try cg.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg.to8()); + try cg.asmRegisterRegister(.{ ._, .mov }, dst_reg, tmp_reg.to8()); }, - .gphi => try self.asmRegisterRegister( + .gphi => try cg.asmRegisterRegister( .{ ._, .mov }, dst_alias, - registerAlias(src_reg, abi_size), + registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), ), .segment, .x87, .mmx, .ip, .cr, .dr, .sse => unreachable, }, - .segment => try self.asmRegisterRegister( + .segment => try cg.asmRegisterRegister( .{ ._, .mov }, dst_reg, switch (src_reg.class()) { - .general_purpose, .gphi, .segment => registerAlias(src_reg, abi_size), + .general_purpose, + .gphi, + .segment, + => registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), .x87, .mmx, .ip, .cr, .dr => unreachable, - .sse => try self.copyToTmpRegister(ty, src_mcv), + .sse => try cg.copyToTmpRegister(ty, src_mcv), }, ), .x87 => switch (src_reg.class()) { .general_purpose, .gphi, .segment, .mmx, .ip, .cr, .dr => unreachable, .x87 => switch (src_reg) { - .st0 => try self.asmRegister(.{ .f_, .st }, dst_reg), + .st0 => try cg.asmRegister(.{ .f_, .st }, dst_reg), .st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) { .st0 => { - try self.asmRegister(.{ .f_p, .st }, .st0); - try self.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1)); + try cg.asmRegister(.{ .f_p, .st }, .st0); + try cg.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1)); }, - .st2, .st3, .st4, .st5, .st6 => if (self.register_manager.isKnownRegFree(.st7)) { - try self.asmRegister(.{ .f_, .ld }, src_reg); - try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); + .st2, .st3, .st4, .st5, .st6 => if (cg.register_manager.isKnownRegFree(.st7)) { + try cg.asmRegister(.{ .f_, .ld }, src_reg); + try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); } else { - try self.asmRegister(.{ .f_, .xch }, src_reg); - try self.asmRegister(.{ .f_, .xch }, dst_reg); - try self.asmRegister(.{ .f_, .xch }, src_reg); + try cg.asmRegister(.{ .f_, .xch }, src_reg); + try cg.asmRegister(.{ .f_, .xch }, dst_reg); + try cg.asmRegister(.{ .f_, .xch }, src_reg); }, .st7 => { - if (!self.register_manager.isKnownRegFree(.st7)) try self.asmRegister(.{ .f_, .free }, dst_reg); - try self.asmRegister(.{ .f_, .ld }, src_reg); - try self.asmOpOnly(.{ .f_cstp, .in }); + if (!cg.register_manager.isKnownRegFree(.st7)) try cg.asmRegister(.{ .f_, .free }, dst_reg); + try cg.asmRegister(.{ .f_, .ld }, src_reg); + try cg.asmOpOnly(.{ .f_cstp, .in }); }, else => unreachable, }, else => unreachable, }, .sse => if (abi_size <= 16) { - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = 16, .alignment = .@"16", })); - try self.asmMemoryRegister(if (self.hasFeature(.avx)) + try cg.asmMemoryRegister(if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } - else if (self.hasFeature(.sse2)) + else if (cg.hasFeature(.sse2)) .{ ._dqa, .mov } else .{ ._ps, .mova }, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .xword } }, }, src_reg.to128()); - try MoveStrategy.read(.load_store_x87, self, dst_reg, .{ + try MoveStrategy.read(.load_store_x87, cg, dst_reg, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .tbyte } }, }); @@ -178688,29 +179039,29 @@ fn genSetReg( }, .mmx => unreachable, .sse => switch (src_reg.class()) { - .general_purpose, .gphi => if (self.hasFeature(.sse2)) try self.asmRegisterRegister( + .general_purpose, .gphi => if (cg.hasFeature(.sse2)) try cg.asmRegisterRegister( switch (abi_size) { - 1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov }, - 5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov }, + 1...4 => if (cg.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov }, + 5...8 => if (cg.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov }, else => unreachable, }, dst_reg.to128(), - registerAlias(src_reg, @max(abi_size, 4)), + registerAlias(src_reg, @intCast(@max(cg.unalignedSize(ty), 4))), ) else { const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4)); - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = frame_size, .alignment = .fromNonzeroByteUnits(frame_size), })); - try self.asmMemoryRegister(.{ ._, .mov }, .{ + try cg.asmMemoryRegister(.{ ._, .mov }, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(abi_size) } }, - }, registerAlias(src_reg, abi_size)); + }, registerAlias(src_reg, @intCast(cg.unalignedSize(ty)))); switch (frame_size) { else => {}, - 8 => try self.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()), + 8 => try cg.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()), } - try self.asmRegisterMemory(switch (frame_size) { + try cg.asmRegisterMemory(switch (frame_size) { 4 => .{ ._ss, .mov }, 8 => .{ ._ps, .movl }, 16 => .{ ._ps, .mova }, @@ -178720,24 +179071,24 @@ fn genSetReg( .mod = .{ .rm = .{ .size = .fromSize(frame_size) } }, }); }, - .segment => try self.genSetReg( + .segment => try cg.genSetReg( dst_reg, ty, - .{ .register = try self.copyToTmpRegister(ty, src_mcv) }, + .{ .register = try cg.copyToTmpRegister(ty, src_mcv) }, opts, ), .x87 => if (abi_size <= 16) { - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = 16, .alignment = .@"16", })); - try MoveStrategy.write(.load_store_x87, self, .{ + try MoveStrategy.write(.load_store_x87, cg, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .tbyte } }, }, src_reg); - try self.asmRegisterMemory(if (self.hasFeature(.avx)) + try cg.asmRegisterMemory(if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } - else if (self.hasFeature(.sse2)) + else if (cg.hasFeature(.sse2)) .{ ._dqa, .mov } else .{ ._ps, .mova }, dst_reg.to128(), .{ @@ -178746,46 +179097,46 @@ fn genSetReg( }); } else unreachable, .mmx, .ip, .cr, .dr => unreachable, - .sse => try self.asmRegisterRegister( + .sse => try cg.asmRegisterRegister( @as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) { else => switch (abi_size) { - 1...16 => if (self.hasFeature(.avx)) + 1...16 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } - else if (self.hasFeature(.sse2)) + else if (cg.hasFeature(.sse2)) .{ ._dqa, .mov } else .{ ._ps, .mova }, - 17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null, + 17...32 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } else null, else => null, }, - .float => switch (ty.scalarType(zcu).floatBits(self.target)) { + .float => switch (ty.scalarType(zcu).floatBits(cg.target)) { 16, 128 => switch (abi_size) { - 2...16 => if (self.hasFeature(.avx)) + 2...16 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } - else if (self.hasFeature(.sse2)) + else if (cg.hasFeature(.sse2)) .{ ._dqa, .mov } else .{ ._ps, .mova }, - 17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null, + 17...32 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } else null, else => null, }, - 32 => if (self.hasFeature(.avx)) .{ .v_ps, .mova } else .{ ._ps, .mova }, - 64 => if (self.hasFeature(.avx)) + 32 => if (cg.hasFeature(.avx)) .{ .v_ps, .mova } else .{ ._ps, .mova }, + 64 => if (cg.hasFeature(.avx)) .{ .v_pd, .mova } - else if (self.hasFeature(.sse2)) + else if (cg.hasFeature(.sse2)) .{ ._pd, .mova } else .{ ._ps, .mova }, 80 => null, else => unreachable, }, - }) orelse return self.fail("TODO implement genSetReg for {f}", .{ty.fmt(pt)}), + }) orelse return cg.fail("TODO implement genSetReg for {f}", .{ty.fmt(pt)}), dst_alias, - registerAlias(src_reg, abi_size), + registerAlias(src_reg, @intCast(cg.unalignedSize(ty))), ), }, .ip, .cr, .dr => unreachable, - } else if ((dst_reg.class() == .gphi) != (src_reg.class() == .gphi)) try self.asmRegisterRegister( + } else if ((dst_reg.class() == .gphi) != (src_reg.class() == .gphi)) try cg.asmRegisterRegister( .{ ._, .mov }, dst_reg.to8(), src_reg.to8(), @@ -178795,41 +179146,41 @@ fn genSetReg( .register_quadruple, => |src_regs| switch (dst_reg.class()) { .general_purpose => switch (src_regs[0].class()) { - .general_purpose => try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts), + .general_purpose => try cg.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts), else => unreachable, }, .sse => switch (src_regs[0].class()) { .general_purpose => if (abi_size <= 16) { - if (self.hasFeature(.avx)) { - try self.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64()); - try self.asmRegisterRegisterRegisterImmediate( + if (cg.hasFeature(.avx)) { + try cg.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64()); + try cg.asmRegisterRegisterRegisterImmediate( .{ .vp_q, .insr }, dst_reg.to128(), dst_reg.to128(), src_regs[1].to64(), .u(1), ); - } else if (self.hasFeature(.sse4_1)) { - try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); - try self.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1)); - } else if (self.hasFeature(.sse2)) { - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); + } else if (cg.hasFeature(.sse4_1)) { + try cg.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); + try cg.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1)); + } else if (cg.hasFeature(.sse2)) { + const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse); + const tmp_lock = cg.register_manager.lockRegAssumeUnused(tmp_reg); + defer cg.register_manager.unlockReg(tmp_lock); - try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); - try self.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64()); - try self.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128()); + try cg.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64()); + try cg.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64()); + try cg.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128()); } else { - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = 16, .alignment = .@"16", })); - for (src_regs, 0..) |src_reg, src_index| try self.asmMemoryRegister(.{ ._, .mov }, .{ + for (src_regs, 0..) |src_reg, src_index| try cg.asmMemoryRegister(.{ ._, .mov }, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .qword, .disp = @intCast(8 * src_index) } }, }, src_reg.to64()); - try self.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{ + try cg.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .xword } }, }); @@ -178843,38 +179194,41 @@ fn genSetReg( .indirect, .load_frame, .lea_frame, - => try @as(MoveStrategy, switch (src_mcv) { - .register_offset => |reg_off| switch (reg_off.off) { - 0 => return self.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts), - else => .{ .load_store = .{ ._, .lea } }, - }, - .indirect => try self.moveStrategy(ty, dst_reg.class(), false), - .load_frame => |frame_addr| try self.moveStrategy( - ty, - dst_reg.class(), - self.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units( - std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(self.target), 8)), - )), - ), - .lea_frame => .{ .load_store = .{ ._, .lea } }, - else => unreachable, - }).read(self, dst_alias, switch (src_mcv) { - .register_offset, .indirect => |reg_off| .{ - .base = .{ .reg = reg_off.reg.to64() }, - .mod = .{ .rm = .{ - .size = self.memSize(ty), - .disp = reg_off.off, - } }, - }, - .load_frame, .lea_frame => |frame_addr| .{ - .base = .{ .frame = frame_addr.index }, - .mod = .{ .rm = .{ - .size = self.memSize(ty), - .disp = frame_addr.off, - } }, - }, - else => unreachable, - }), + => { + const dst_rc = dst_reg.class(); + try @as(MoveStrategy, switch (src_mcv) { + .register_offset => |reg_off| switch (reg_off.off) { + 0 => return cg.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts), + else => .{ .load_store = .{ ._, .lea } }, + }, + .indirect => try cg.moveStrategy(ty, dst_rc, false), + .load_frame => |frame_addr| try cg.moveStrategy( + ty, + dst_rc, + cg.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units( + std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(cg.target), 8)), + )), + ), + .lea_frame => .{ .load_store = .{ ._, .lea } }, + else => unreachable, + }).read(cg, dst_alias, switch (src_mcv) { + .register_offset, .indirect => |reg_off| .{ + .base = .{ .reg = reg_off.reg.to64() }, + .mod = .{ .rm = .{ + .size = cg.memSize(ty, dst_rc), + .disp = reg_off.off, + } }, + }, + .load_frame, .lea_frame => |frame_addr| .{ + .base = .{ .frame = frame_addr.index }, + .mod = .{ .rm = .{ + .size = cg.memSize(ty, dst_rc), + .disp = frame_addr.off, + } }, + }, + else => unreachable, + }); + }, .register_overflow => |src_reg_ov| { const ip = &zcu.intern_pool; const first_ty: Type = .fromInterned(first_ty: switch (ip.indexToKey(ty.toIntern())) { @@ -178891,116 +179245,117 @@ fn genSetReg( }); const first_size: u31 = @intCast(first_ty.abiSize(zcu)); const frame_size = std.math.ceilPowerOfTwoAssert(u32, abi_size); - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = frame_size, .alignment = .fromNonzeroByteUnits(frame_size), })); - try self.asmMemoryRegister(.{ ._, .mov }, .{ + try cg.asmMemoryRegister(.{ ._, .mov }, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(first_size) } }, }, registerAlias(src_reg_ov.reg, first_size)); - try self.asmSetccMemory(src_reg_ov.eflags, .{ + try cg.asmSetccMemory(src_reg_ov.eflags, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .byte, .disp = first_size } }, }); - try self.asmRegisterMemory(.{ ._, .mov }, registerAlias(dst_reg, abi_size), .{ + try cg.asmRegisterMemory(.{ ._, .mov }, registerAlias(dst_reg, abi_size), .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(frame_size) } }, }); }, .register_mask => |src_reg_mask| { assert(src_reg_mask.reg.isClass(.sse)); - const has_avx = self.hasFeature(.avx); + const has_avx = cg.hasFeature(.avx); const bits_reg = switch (dst_reg.class()) { .general_purpose => dst_reg, - else => try self.register_manager.allocReg(null, abi.RegisterClass.gp), + else => try cg.register_manager.allocReg(null, abi.RegisterClass.gp), }; - const bits_lock = self.register_manager.lockReg(bits_reg); - defer if (bits_lock) |lock| self.register_manager.unlockReg(lock); + const bits_lock = cg.register_manager.lockReg(bits_reg); + defer if (bits_lock) |lock| cg.register_manager.unlockReg(lock); const pack_reg = switch (src_reg_mask.info.scalar) { else => src_reg_mask.reg, - .word => try self.register_manager.allocReg(null, abi.RegisterClass.sse), + .word => try cg.register_manager.allocReg(null, abi.RegisterClass.sse), }; - const pack_lock = self.register_manager.lockReg(pack_reg); - defer if (pack_lock) |lock| self.register_manager.unlockReg(lock); + const pack_lock = cg.register_manager.lockReg(pack_reg); + defer if (pack_lock) |lock| cg.register_manager.unlockReg(lock); - var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(self.target), 8)); + var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(cg.target), 8)); switch (src_reg_mask.info.scalar) { else => {}, .word => { const src_alias = registerAlias(src_reg_mask.reg, mask_size); const pack_alias = registerAlias(pack_reg, mask_size); if (has_avx) { - try self.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias); + try cg.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias); } else { - try self.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias); - try self.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias); + try cg.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias); + try cg.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias); } mask_size = std.math.divCeil(u32, mask_size, 2) catch unreachable; }, } - try self.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) { + try cg.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) { .byte, .word => if (has_avx) .vp_b else .p_b, .dword => if (has_avx) .v_ps else ._ps, .qword => if (has_avx) .v_pd else ._pd, else => unreachable, }, .movmsk }, bits_reg.to32(), registerAlias(pack_reg, mask_size)); - if (src_reg_mask.info.inverted) try self.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size)); - try self.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{}); + if (src_reg_mask.info.inverted) try cg.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size)); + try cg.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{}); }, .memory, .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => { + const dst_rc = dst_reg.class(); switch (src_mcv) { .memory => |addr| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr| - return (try self.moveStrategy( + return (try cg.moveStrategy( ty, - dst_reg.class(), + dst_rc, ty.abiAlignment(zcu).check(@as(u32, @bitCast(small_addr))), - )).read(self, dst_alias, .{ + )).read(cg, dst_alias, .{ .base = .{ .reg = .ds }, .mod = .{ .rm = .{ - .size = self.memSize(ty), + .size = cg.memSize(ty, dst_rc), .disp = small_addr, } }, }), - .load_nav => |nav| switch (dst_reg.class()) { + .load_nav => |nav| switch (dst_rc) { .general_purpose, .gphi => { - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ + try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ .base = .{ .nav = nav }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } }, }); return; }, .segment, .mmx, .ip, .cr, .dr => unreachable, .x87, .sse => {}, }, - .load_uav => |uav| switch (dst_reg.class()) { + .load_uav => |uav| switch (dst_rc) { .general_purpose, .gphi => { - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ + try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ .base = .{ .uav = uav }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } }, }); return; }, .segment, .mmx, .ip, .cr, .dr => unreachable, .x87, .sse => {}, }, - .load_lazy_sym => |lazy_sym| switch (dst_reg.class()) { + .load_lazy_sym => |lazy_sym| switch (dst_rc) { .general_purpose, .gphi => { - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ + try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ .base = .{ .lazy_sym = lazy_sym }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } }, }); return; }, .segment, .mmx, .ip, .cr, .dr => unreachable, .x87, .sse => {}, }, - .load_extern_func => |extern_func| switch (dst_reg.class()) { + .load_extern_func => |extern_func| switch (dst_rc) { .general_purpose, .gphi => { - try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ + try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{ .base = .{ .extern_func = extern_func }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } }, }); return; }, @@ -179010,40 +179365,40 @@ fn genSetReg( else => unreachable, } - const addr_reg = try self.copyToTmpRegister(.usize, src_mcv.address()); - const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg); - defer self.register_manager.unlockReg(addr_lock); + const addr_reg = try cg.copyToTmpRegister(.usize, src_mcv.address()); + const addr_lock = cg.register_manager.lockRegAssumeUnused(addr_reg); + defer cg.register_manager.unlockReg(addr_lock); - try (try self.moveStrategy(ty, dst_reg.class(), false)).read(self, dst_alias, .{ + try (try cg.moveStrategy(ty, dst_rc, false)).read(cg, dst_alias, .{ .base = .{ .reg = addr_reg.to64() }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } }, }); }, - .lea_nav => |nav| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ + .lea_nav => |nav| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ .base = .{ .nav = nav }, }), - .lea_uav => |uav| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ + .lea_uav => |uav| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ .base = .{ .uav = uav }, }), - .lea_lazy_sym => |lazy_sym| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ + .lea_lazy_sym => |lazy_sym| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ .base = .{ .lazy_sym = lazy_sym }, }), - .lea_extern_func => |lazy_sym| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ + .lea_extern_func => |lazy_sym| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{ .base = .{ .extern_func = lazy_sym }, }), - .air_ref => |src_ref| try self.genSetReg(dst_reg, ty, try self.resolveInst(src_ref), opts), + .air_ref => |src_ref| try cg.genSetReg(dst_reg, ty, try cg.resolveInst(src_ref), opts), } } fn genSetMem( - self: *CodeGen, + cg: *CodeGen, base: Memory.Base, disp: i32, ty: Type, src_mcv: MCValue, opts: CopyOptions, ) InnerError!void { - const pt = self.pt; + const pt = cg.pt; const zcu = pt.zcu; const abi_size: u32 = @intCast(ty.abiSize(zcu)); const dst_ptr_mcv: MCValue = switch (base) { @@ -179053,11 +179408,11 @@ fn genSetMem( .table, .rip_inst, .lazy_sym => unreachable, .nav => |nav| { // hack around linker relocation bugs - const addr_reg = try self.copyToTmpRegister(.usize, .{ .lea_nav = nav }); - const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg); - defer self.register_manager.unlockReg(addr_lock); + const addr_reg = try cg.copyToTmpRegister(.usize, .{ .lea_nav = nav }); + const addr_lock = cg.register_manager.lockRegAssumeUnused(addr_reg); + defer cg.register_manager.unlockReg(addr_lock); - return self.genSetMem(.{ .reg = addr_reg }, disp, ty, src_mcv, opts); + return cg.genSetMem(.{ .reg = addr_reg }, disp, ty, src_mcv, opts); }, .uav => |uav| .{ .lea_uav = uav }, .extern_func => |extern_func| .{ .lea_extern_func = extern_func }, @@ -179067,10 +179422,14 @@ fn genSetMem( .unreach, .dead, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, => unreachable, - .undef => if (opts.safety) try self.genInlineMemset( + .undef => if (opts.safety) try cg.genInlineMemset( dst_ptr_mcv, src_mcv, .{ .immediate = abi_size }, @@ -179085,7 +179444,7 @@ fn genSetMem( .signed => .s(@truncate(@as(i64, @bitCast(imm)))), .unsigned => .u(@as(u32, @intCast(imm))), }; - try self.asmMemoryImmediate( + try cg.asmMemoryImmediate( .{ ._, .mov }, .{ .base = base, .mod = .{ .rm = .{ .size = .fromSize(abi_size), @@ -179096,7 +179455,7 @@ fn genSetMem( }, 3, 5...7 => unreachable, else => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) |small| { - try self.asmMemoryImmediate( + try cg.asmMemoryImmediate( .{ ._, .mov }, .{ .base = base, .mod = .{ .rm = .{ .size = .fromSize(abi_size), @@ -179106,7 +179465,7 @@ fn genSetMem( ); } else { var offset: i32 = 0; - while (offset < abi_size) : (offset += 4) try self.asmMemoryImmediate( + while (offset < abi_size) : (offset += 4) try cg.asmMemoryImmediate( .{ ._, .mov }, .{ .base = base, .mod = .{ .rm = .{ .size = .dword, @@ -179120,7 +179479,7 @@ fn genSetMem( ); }, }, - .eflags => |cc| try self.asmSetccMemory(cc, .{ .base = base, .mod = .{ + .eflags => |cc| try cg.asmSetccMemory(cc, .{ .base = base, .mod = .{ .rm = .{ .size = .byte, .disp = disp }, } }), .register => |src_reg| { @@ -179128,75 +179487,75 @@ fn genSetMem( const mem_size = switch (base) { .frame => |base_fi| mem_size: { assert(disp >= 0); - const frame_abi_size = self.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)]; - const frame_spill_pad = self.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)]; + const frame_abi_size = cg.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)]; + const frame_spill_pad = cg.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)]; assert(frame_abi_size - frame_spill_pad - disp >= abi_size); break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size else abi_size; }, else => abi_size, }; - const src_alias = registerAlias(src_reg, @intCast(self.unalignedSize(ty))); - const src_class = src_alias.class(); - const src_size: Memory.Size = switch (src_class) { + const src_alias = registerAlias(src_reg, @intCast(cg.unalignedSize(ty))); + const src_rc = src_alias.class(); + const src_size: Memory.Size = switch (src_rc) { .general_purpose, .gphi, .segment, .ip, .cr, .dr => src_alias.size(), .mmx, .sse => .fromSize(abi_size), - .x87 => switch (abi.classifySystemV(ty, zcu, self.target, .other)[0]) { + .x87 => switch (abi.classifySystemV(ty, zcu, cg.target, .other)[0]) { else => unreachable, .float => .dword, .float_combine, .sse => .qword, .x87 => .tbyte, }, }; - const src_bit_size = src_size.bitSize(self.target); + const src_bit_size = src_size.bitSize(cg.target); const src_align: InternPool.Alignment = .fromNonzeroByteUnits(std.math.ceilPowerOfTwoAssert(u64, src_bit_size)); const src_byte_size = @divExact(src_bit_size, 8); if (src_byte_size > mem_size) { - const frame_index = try self.allocFrameIndex(.init(.{ + const frame_index = try cg.allocFrameIndex(.init(.{ .size = src_byte_size, .alignment = src_align, })); const frame_mcv: MCValue = .{ .load_frame = .{ .index = frame_index } }; - try (try self.moveStrategy(ty, src_class, true)).write(self, .{ + try (try cg.moveStrategy(ty, src_rc, true)).write(cg, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = src_size } }, }, src_alias); - try self.genSetMem(base, disp, ty, frame_mcv, opts); - try self.freeValue(frame_mcv, .{}); - } else try (try self.moveStrategy(ty, src_class, switch (base) { + try cg.genSetMem(base, disp, ty, frame_mcv, opts); + try cg.freeValue(frame_mcv, .{}); + } else try (try cg.moveStrategy(ty, src_rc, switch (base) { .none => src_align.check(@as(u32, @bitCast(disp))), .reg => |reg| switch (reg) { .es, .cs, .ss, .ds => src_align.check(@as(u32, @bitCast(disp))), else => false, }, - .frame => |frame_index| self.getFrameAddrAlignment(.{ + .frame => |frame_index| cg.getFrameAddrAlignment(.{ .index = frame_index, .off = disp, }).compare(.gte, src_align), .table, .rip_inst, .lazy_sym, .extern_func => unreachable, .nav => |nav| ip.getNav(nav).resolved.?.@"align".compare(.gte, src_align), .uav => |uav| Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).compare(.gte, src_align), - })).write(self, .{ + })).write(cg, .{ .base = base, .mod = .{ .rm = .{ .size = src_size, .disp = disp } }, }, src_alias); }, inline .register_pair, .register_triple, .register_quadruple => |src_regs| { var part_disp: i32 = disp; - for (try self.splitType(src_regs.len, ty), src_regs) |src_ty, src_reg| { - try self.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts); - part_disp += @intCast(src_ty.abiSize(zcu)); + for (try cg.splitType(src_regs.len, ty), src_regs) |src_ty, src_reg| { + try cg.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts); + part_disp += @intCast(cg.unalignedSize(src_ty)); } }, .register_overflow => |ro| switch (ty.zigTypeTag(zcu)) { .@"struct" => { - try self.genSetMem( + try cg.genSetMem( base, disp + @as(i32, @intCast(ty.structFieldOffset(0, zcu))), ty.fieldType(0, zcu), .{ .register = ro.reg }, opts, ); - try self.genSetMem( + try cg.genSetMem( base, disp + @as(i32, @intCast(ty.structFieldOffset(1, zcu))), ty.fieldType(1, zcu), @@ -179207,8 +179566,8 @@ fn genSetMem( .optional => { assert(!ty.optionalReprIsPayload(zcu)); const child_ty = ty.optionalChild(zcu); - try self.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts); - try self.genSetMem( + try cg.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts); + try cg.genSetMem( base, disp + @as(i32, @intCast(child_ty.abiSize(zcu))), .bool, @@ -179216,37 +179575,37 @@ fn genSetMem( opts, ); }, - else => return self.fail("TODO implement genSetMem for {s} of {f}", .{ + else => return cg.fail("TODO implement genSetMem for {s} of {f}", .{ @tagName(src_mcv), ty.fmt(pt), }), }, .register_offset => |reg_off| { - const src_reg = self.copyToTmpRegister(ty, src_mcv) catch |err| switch (err) { + const src_reg = cg.copyToTmpRegister(ty, src_mcv) catch |err| switch (err) { error.OutOfRegisters => { - const src_reg = registerAlias(reg_off.reg, abi_size); - try self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{ - .base = .{ .reg = src_reg }, + const src_alias = registerAlias(reg_off.reg, @intCast(cg.unalignedSize(ty))); + try cg.asmRegisterMemory(.{ ._, .lea }, src_alias, .{ + .base = .{ .reg = src_alias }, .mod = .{ .rm = .{ .disp = reg_off.off } }, }); - try self.genSetMem(base, disp, ty, .{ .register = reg_off.reg }, opts); - return self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{ - .base = .{ .reg = src_reg }, + try cg.genSetMem(base, disp, ty, .{ .register = reg_off.reg }, opts); + return cg.asmRegisterMemory(.{ ._, .lea }, src_alias, .{ + .base = .{ .reg = src_alias }, .mod = .{ .rm = .{ .disp = -reg_off.off } }, }); }, else => |e| return e, }; - const src_lock = self.register_manager.lockRegAssumeUnused(src_reg); - defer self.register_manager.unlockReg(src_lock); + const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg); + defer cg.register_manager.unlockReg(src_lock); - try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); + try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); }, .register_mask => { - const src_reg = try self.copyToTmpRegister(ty, src_mcv); - const src_lock = self.register_manager.lockRegAssumeUnused(src_reg); - defer self.register_manager.unlockReg(src_lock); + const src_reg = try cg.copyToTmpRegister(ty, src_mcv); + const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg); + defer cg.register_manager.unlockReg(src_lock); - try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); + try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); }, .memory, .indirect, @@ -179263,15 +179622,15 @@ fn genSetMem( => switch (abi_size) { 0 => {}, 1, 2, 4, 8 => { - const src_reg = try self.copyToTmpRegister(ty, src_mcv); - const src_lock = self.register_manager.lockRegAssumeUnused(src_reg); - defer self.register_manager.unlockReg(src_lock); + const src_reg = try cg.copyToTmpRegister(ty, src_mcv); + const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg); + defer cg.register_manager.unlockReg(src_lock); - try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); + try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts); }, - else => try self.genInlineMemcpy(dst_ptr_mcv, src_mcv.address(), .{ .immediate = abi_size }, .{ .no_alias = true }), + else => try cg.genInlineMemcpy(dst_ptr_mcv, src_mcv.address(), .{ .immediate = abi_size }, .{ .no_alias = true }), }, - .air_ref => |src_ref| try self.genSetMem(base, disp, ty, try self.resolveInst(src_ref), opts), + .air_ref => |src_ref| try cg.genSetMem(base, disp, ty, try cg.resolveInst(src_ref), opts), } } @@ -179780,7 +180139,7 @@ fn atomicOp( mir_tag, sse_reg.to128(), sse_reg.to128(), - try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }), + try val_mcv.mem(self, .{ .size = self.memSize(val_ty, sse_reg.class()) }), ) else try self.asmRegisterRegisterRegister( mir_tag, sse_reg.to128(), @@ -179793,7 +180152,7 @@ fn atomicOp( ._ss, ._sd => if (val_mcv.isBase()) try self.asmRegisterMemory( mir_tag, sse_reg.to128(), - try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }), + try val_mcv.mem(self, .{ .size = self.memSize(val_ty, sse_reg.class()) }), ) else try self.asmRegisterRegister( mir_tag, sse_reg.to128(), @@ -180369,7 +180728,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { mir_tag, dst_alias, rhs_alias, - try other_mcv.mem(self, .{ .size = self.memSize(ty) }), + try other_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }), mask_alias, ) else try self.asmRegisterRegisterRegisterRegister( mir_tag, @@ -180384,7 +180743,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { } else if (has_blend) if (other_mcv.isBase()) try self.asmRegisterMemoryRegister( mir_tag, dst_alias, - try other_mcv.mem(self, .{ .size = self.memSize(ty) }), + try other_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }), mask_alias, ) else try self.asmRegisterRegisterRegister( mir_tag, @@ -180527,7 +180886,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { } }))); const mask_mem: Memory = .{ .base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = self.memSize(ty, mask_reg.class()) } }, }; if (has_avx) try self.asmRegisterRegisterMemory( .{ .vp_b, .shuf }, @@ -180552,7 +180911,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { const mask_mcv = try self.lowerValue(try pt.aggregateValue(mask_ty, mask_elems)); const mask_mem: Memory = .{ .base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) }, - .mod = .{ .rm = .{ .size = self.memSize(ty) } }, + .mod = .{ .rm = .{ .size = self.memSize(ty, mask_reg.class()) } }, }; if (has_avx) { try self.asmRegisterRegisterMemory( @@ -180671,7 +181030,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { mir_tag, dst_alias, rhs_alias, - try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }), + try lhs_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }), mask_alias, ) else try self.asmRegisterRegisterRegisterRegister( mir_tag, @@ -180686,7 +181045,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { } else if (has_blend) if (lhs_mcv.isBase()) try self.asmRegisterMemoryRegister( mir_tag, dst_alias, - try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }), + try lhs_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }), mask_alias, ) else try self.asmRegisterRegisterRegister( mir_tag, @@ -181205,9 +181564,9 @@ fn resolveCallingConventionValues( result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16); switch (cc) { + else => unreachable, .x86_64_sysv => {}, .x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space), - else => unreachable, } // Return values @@ -181223,10 +181582,17 @@ fn resolveCallingConventionValues( var ret_sse = abi.getCAbiSseReturnRegs(cc); var ret_x87 = abi.getCAbiX87ReturnRegs(cc); - const classes: []const abi.Class = switch (cc) { - .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, cg.target, .ret), .none), - .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu, cg.target, .ret)}, + var classes_buf: [8]abi.Class = undefined; + const classes = classes: switch (cc) { else => unreachable, + .x86_64_sysv => { + classes_buf = abi.classifySystemV(ret_ty, zcu, cg.target, .ret); + break :classes std.mem.sliceTo(&classes_buf, .none); + }, + .x86_64_win => { + classes_buf[0] = abi.classifyWindows(ret_ty, zcu, cg.target, .ret); + break :classes classes_buf[0..1]; + }, }; for (classes) |class| switch (class) { .integer => { @@ -181238,16 +181604,11 @@ fn resolveCallingConventionValues( ret_gpr = ret_gpr[1..]; }, .sse, .float, .float_combine, .win_i128 => { - const abi_size: u32 = @intCast(ret_ty.abiSize(zcu)); - const reg_size = @min(abi_size, cg.vectorSize(.float)); - var byte_offset: u32 = 0; - while (byte_offset < abi_size) : (byte_offset += reg_size) { - const ret_sse_reg = registerAlias(ret_sse[0], reg_size); - ret_sse = ret_sse[1..]; - - ret_tracking[ret_tracking_len] = .init(.{ .register = ret_sse_reg }); - ret_tracking_len += 1; - } + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_sse[0], @intCast(ret_ty.abiSize(zcu))), + }); + ret_tracking_len += 1; + ret_sse = ret_sse[1..]; }, .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)), .x87 => { @@ -181256,7 +181617,8 @@ fn resolveCallingConventionValues( ret_x87 = ret_x87[1..]; }, .x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)), - .memory, .integer_per_element => { + .none => unreachable, + .memory => { ret_tracking[ret_tracking_len] = .{ .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } }, .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }, @@ -181265,7 +181627,59 @@ fn resolveCallingConventionValues( ret_gpr = ret_gpr[1..]; param_gpr_index += 1; }, - .none => unreachable, + .integer_per_element => { + const len: u32 = @intCast(ret_ty.vectorLen(zcu)); + const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); + for (ret_tracking[ret_tracking_len..][0..len], ret_gpr[0..len]) |*tracking, gpr| + tracking.* = .init(.{ .register = registerAlias(gpr, alias_size) }); + ret_tracking_len += len; + ret_gpr = ret_gpr[len..]; + }, + .sse_per_element => { + const len: u32 = @intCast(ret_ty.vectorLen(zcu)); + const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); + for (ret_tracking[ret_tracking_len..][0..len], ret_sse[0..len]) |*tracking, sse| + tracking.* = .init(.{ .register = registerAlias(sse, alias_size) }); + ret_tracking_len += len; + ret_sse = ret_sse[len..]; + }, + .sse_sse_x87_per_qword, .sse_per_xword, .sse_per_yword, .sse_per_zword => { + const reg_size: u32 = switch (class) { + else => unreachable, + .sse_sse_x87_per_qword => 8, + .sse_per_xword => 16, + .sse_per_yword => 32, + .sse_per_zword => 64, + }; + var byte_offset: u32 = 0; + const unaligned_size = cg.unalignedSize(ret_ty); + while (byte_offset < unaligned_size) : (byte_offset += reg_size) { + switch (@as(enum { sse, x87 }, switch (class) { + else => unreachable, + .sse_sse_x87_per_qword => switch (byte_offset) { + 0 => .sse, // duck + 8 => .sse, // duck + else => .x87, // goose! + }, + .sse_per_xword, .sse_per_yword, .sse_per_zword => .sse, + })) { + .sse => { + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_sse[0], reg_size), + }); + ret_tracking_len += 1; + ret_sse = ret_sse[1..]; + }, + .x87 => { + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_x87[0], reg_size), + }); + ret_tracking_len += 1; + ret_x87 = ret_x87[1..]; + }, + } + } + }, }; result.return_value = switch (ret_tracking_len) { else => unreachable, @@ -181293,12 +181707,12 @@ fn resolveCallingConventionValues( assert(ty.hasRuntimeBits(zcu)); result.air_arg_count += 1; switch (cc) { + else => unreachable, .x86_64_sysv => {}, .x86_64_win => { param_gpr_index = @max(param_gpr_index, param_sse_index); param_sse_index = param_gpr_index; }, - else => unreachable, } const save_param_gpr_index = param_gpr_index; @@ -181307,17 +181721,25 @@ fn resolveCallingConventionValues( var arg_mcv: [4]MCValue = undefined; var arg_mcv_len: u32 = 0; - const classes = switch (cc) { - .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .arg), .none), - .x86_64_win => &.{abi.classifyWindows(ty, zcu, cg.target, .arg)}, + var classes_buf: [8]abi.Class = undefined; + const classes = classes: switch (cc) { else => unreachable, + .x86_64_sysv => { + classes_buf = abi.classifySystemV(ty, zcu, cg.target, .arg); + break :classes std.mem.sliceTo(&classes_buf, .none); + }, + .x86_64_win => { + classes_buf[0] = abi.classifyWindows(ty, zcu, cg.target, .arg); + break :classes classes_buf[0..1]; + }, }; classes: for (classes) |class| switch (class) { .integer => { if (param_gpr_index >= param_gpr.len) break; - arg_mcv[arg_mcv_len] = .{ - .register = registerAlias(param_gpr[param_gpr_index], @intCast(@min(ty.abiSize(zcu), 8))), - }; + arg_mcv[arg_mcv_len] = .{ .register = registerAlias( + param_gpr[param_gpr_index], + @intCast(@min(ty.abiSize(zcu), 8)), + ) }; arg_mcv_len += 1; param_gpr_index += 1; }, @@ -181338,48 +181760,93 @@ fn resolveCallingConventionValues( .sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)), .x87, .x87up, .memory, .win_i128 => switch (cc) { .x86_64_sysv => switch (class) { + else => unreachable, .x87, .x87up, .memory => break, - else => unreachable, }, - .x86_64_win => if (ty.abiSize(zcu) > 8) { - if (param_gpr_index < param_gpr.len) { - arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }; - arg_mcv_len += 1; - param_gpr_index += 1; - } else { - assert(arg_mcv_len == 0); - const param_align = Type.usize.abiAlignment(zcu); - result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count)); - result.stack_align = result.stack_align.max(param_align); - arg.* = .{ .indirect_load_frame = .{ - .index = stack_frame_base, - .off = result.stack_byte_count, - } }; - result.stack_byte_count += @intCast(Type.usize.abiSize(zcu)); - continue :params; - } - } else break, + .x86_64_win => if (param_gpr_index < param_gpr.len) { + arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }; + arg_mcv_len += 1; + param_gpr_index += 1; + } else { + assert(arg_mcv_len == 0); + const param_align = Type.usize.abiAlignment(zcu); + result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count)); + result.stack_align = result.stack_align.max(param_align); + arg.* = .{ .indirect_load_frame = .{ + .index = stack_frame_base, + .off = result.stack_byte_count, + } }; + result.stack_byte_count += @intCast(Type.usize.abiSize(zcu)); + continue :params; + }, else => unreachable, }, .none => unreachable, - .integer_per_element => { - const remaining_param_gpr_len: u3 = @intCast(param_gpr.len - param_gpr_index); - param_gpr_index = @intCast(param_gpr.len); - + .integer_per_element, + .sse_per_element, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => { + const len = switch (class) { + else => unreachable, + .integer_per_element, .sse_per_element => ty.vectorLen(zcu), + .sse_per_xword => @divExact(ty.abiSize(zcu), 16), + .sse_per_yword => @divExact(ty.abiSize(zcu), 32), + .sse_per_zword => @divExact(ty.abiSize(zcu), 64), + }; + const param_reg_len: u32 = @intCast(@min(len, switch (class) { + else => unreachable, + .integer_per_element => param_gpr.len - param_gpr_index, + .sse_per_element, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => param_sse.len - param_sse_index, + })); + const frame_elem_len = len - param_reg_len; const frame_elem_align = 8; - const frame_elems_len = ty.vectorLen(zcu) - remaining_param_gpr_len; - const frame_elem_size = std.mem.alignForward(u64, ty.childType(zcu).abiSize(zcu), frame_elem_align); - const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size); + const frame_elem_size = switch (class) { + else => unreachable, + .integer_per_element, .sse_per_element => std.mem.alignForward( + u64, + ty.childType(zcu).abiSize(zcu), + frame_elem_align, + ), + .sse_per_xword, .sse_per_yword, .sse_per_zword => 8, + }; + const frame_size: u31 = @intCast(frame_elem_size * frame_elem_len); - result.stack_byte_count = std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align); - arg_mcv[arg_mcv_len] = .{ .elementwise_args = .{ - .regs = remaining_param_gpr_len, - .frame_off = @intCast(result.stack_byte_count), + if (frame_size > 0) result.stack_byte_count = + std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align); + const info: ArgsInfo = .{ + .info = .{ + .reg_index = @intCast(param_gpr_index), + .frame_off = @intCast(result.stack_byte_count), + }, .frame_index = stack_frame_base, - } }; + }; + arg_mcv[arg_mcv_len] = switch (class) { + else => unreachable, + .integer_per_element => .{ .elementwise_gpr = info }, + .sse_per_element => .{ .elementwise_sse = info }, + .sse_per_xword => .{ .xwordwise_sse = info }, + .sse_per_yword => .{ .ywordwise_sse = info }, + .sse_per_zword => .{ .zwordwise_sse = info }, + }; arg_mcv_len += 1; + switch (class) { + else => unreachable, + .integer_per_element => param_gpr_index += param_reg_len, + .sse_per_element, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => param_sse_index += param_reg_len, + } result.stack_byte_count += frame_size; }, + .sse_sse_x87_per_qword => unreachable, // thank goodness } else { arg.* = switch (arg_mcv_len) { else => unreachable, @@ -181593,14 +182060,17 @@ fn registerAlias(reg: Register, size_bytes: u32) Register { }; } -fn memSize(self: *CodeGen, ty: Type) Memory.Size { +fn memSize(self: *CodeGen, ty: Type, class: Register.Class) Memory.Size { const zcu = self.pt.zcu; return if (self.floatBits(ty)) |float_bits| .fromBitSize(float_bits) else if (ty.isVector(zcu) and ty.vectorLen(zcu) == 1 and self.floatBits(ty.childType(zcu)) == 80) .tbyte else - .fromSize(@intCast(ty.abiSize(zcu))); + .fromSize(@intCast(switch (class) { + .general_purpose, .gphi, .segment, .x87, .ip, .cr, .dr => self.unalignedSize(ty), + .mmx, .sse => ty.abiSize(zcu), + })); } fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { @@ -181610,7 +182080,10 @@ fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Ty var parts: [parts_len]Type = undefined; switch (ip.indexToKey(ty.toIntern())) { .vector_type => |vector_type| if (std.math.divExact(u32, vector_type.len, parts_len)) |vec_len| { - return @splat(try pt.vectorType(.{ .len = vec_len, .child = vector_type.child })); + return @splat(switch (vec_len) { + 1 => .fromInterned(vector_type.child), + else => try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }), + }); } else |err| switch (err) { error.DivisionByZero => unreachable, error.UnexpectedRemainder => {}, @@ -181951,7 +182424,11 @@ const Temp = struct { .lea_lazy_sym, .lea_extern_func, .load_extern_func, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => false, @@ -182414,7 +182891,11 @@ const Temp = struct { .register_overflow, .register_mask, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, // not a valid pointer @@ -182546,7 +183027,7 @@ const Temp = struct { try cg.asmMemoryImmediate( .{ ._, .mov }, try ptr.tracking(cg).short.deref().mem(cg, .{ - .size = cg.memSize(val_ty), + .size = cg.memSize(val_ty, .general_purpose), }), val_op, ); @@ -182566,10 +183047,9 @@ const Temp = struct { try ptr.tracking(cg).short.deref().mem(cg, .{ .size = .byte }), ); }, - .register => |val_reg| try ptr.storeRegs(val_ty, &.{registerAlias( - val_reg, - @intCast(val_ty.abiSize(cg.pt.zcu)), - )}, cg), + .register => |val_reg| try ptr.storeRegs(val_ty, &.{ + registerAlias(val_reg, @intCast(cg.unalignedSize(val_ty))), + }, cg), inline .register_pair, .register_triple, .register_quadruple, @@ -182679,14 +183159,10 @@ const Temp = struct { .s(val_simm32) else continue :val_to_gpr; - try cg.asmMemoryImmediate( - .{ ._, .mov }, - try dst.tracking(cg).short.mem(cg, .{ - .size = cg.memSize(val_ty), - .disp = opts.disp, - }), - val_op, - ); + try cg.asmMemoryImmediate(.{ ._, .mov }, try dst.tracking(cg).short.mem(cg, .{ + .size = cg.memSize(val_ty, .general_purpose), + .disp = opts.disp, + }), val_op); }, .eflags => |cc| try cg.asmSetccMemory( cc, @@ -182758,7 +183234,7 @@ const Temp = struct { while (try ptr.toRegClass(false, .general_purpose, cg)) {}, } try strat.read(cg, dst_reg, try ptr.tracking(cg).short.deref().mem(cg, .{ - .size = cg.memSize(dst_ty), + .size = cg.memSize(dst_ty, dst_rc), })); } @@ -182767,7 +183243,9 @@ const Temp = struct { const ip = &zcu.intern_pool; var part_disp: u31 = 0; var deferred_disp: u31 = 0; - var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu)); + const is_full = src_regs.len == 1 and + (src_regs[0].class() == .sse or !(src_ty.isRuntimeFloat() or src_ty.isVector(zcu))); + var src_size: u32 = @intCast(if (is_full) src_ty.abiSize(zcu) else cg.unalignedSize(src_ty)); for (src_regs, 0..) |src_reg, part_index| { const part_ty: Type = if (src_regs.len == 1) src_ty @@ -182782,13 +183260,17 @@ const Temp = struct { break :part_ty .usize; }, .array_type => { - assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable); - break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_abi_size, 8)); + assert(src_regs.len - part_index == std.math.divCeil(u32, src_size, 8) catch unreachable); + break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_size, 8)); + }, + .vector_type => |vector_type| switch (@divExact(vector_type.len, src_regs.len)) { + 0 => unreachable, + 1 => .fromInterned(vector_type.child), + else => |len| try cg.pt.vectorType(.{ + .len = @intCast(len), + .child = vector_type.child, + }), }, - .vector_type => |vector_type| try cg.pt.vectorType(.{ - .len = @intCast(@divExact(vector_type.len, src_regs.len)), - .child = vector_type.child, - }), .opt_type => |opt_child| switch (ip.indexToKey(opt_child)) { else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }), .ptr_type => |ptr_info| { @@ -182798,8 +183280,8 @@ const Temp = struct { }, }, .struct_type, .union_type => { - assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable); - break :part_ty switch (src_abi_size) { + assert(src_regs.len - part_index == std.math.divCeil(u32, src_size, 8) catch unreachable); + break :part_ty switch (src_size) { 0, 3, 5...7 => unreachable, 1 => .u8, 2 => .u16, @@ -182812,7 +183294,8 @@ const Temp = struct { break :part_ty .fromInterned(tuple_type.types.get(ip)[part_index]); }, }; - const part_size: u31 = @intCast(part_ty.abiSize(zcu)); + const part_size: u31 = + @intCast(if (is_full) part_ty.abiSize(zcu) else cg.unalignedSize(part_ty)); const src_rc = src_reg.class(); if (src_rc == .x87 or std.math.isPowerOfTwo(part_size)) { // hack around linker relocation bugs @@ -182827,8 +183310,9 @@ const Temp = struct { .x87 => switch (abi.classifySystemV(src_ty, zcu, cg.target, .other)[part_index]) { else => unreachable, .float => .dword, - .float_combine, .sse => .qword, - .x87 => .tbyte, + .float_combine, .sse, .sseup => .qword, + .x87, .x87up => .tbyte, + .none => .fromBitSize(8 * part_size), }, }, .disp = part_disp, @@ -182847,19 +183331,20 @@ const Temp = struct { try ptr.toOffset(deferred_disp, cg); deferred_disp = 0; var src_ptr = try cg.tempInit(.usize, .{ .lea_frame = .{ .index = frame_index } }); - try ptr.memcpy(&src_ptr, src_abi_size, cg); + try ptr.memcpy(&src_ptr, src_size, cg); try src_ptr.die(cg); } part_disp += part_size; deferred_disp += part_size; - src_abi_size -= part_size; + src_size -= part_size; } } fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void { - const strat = try cg.moveStrategy(dst_ty, dst_reg.class(), false); + const dst_rc = dst_reg.class(); + const strat = try cg.moveStrategy(dst_ty, dst_rc, false); try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{ - .size = cg.memSize(dst_ty), + .size = cg.memSize(dst_ty, dst_rc), .disp = disp, })); } @@ -182870,7 +183355,7 @@ const Temp = struct { if (src_rc == .x87 or std.math.isPowerOfTwo(src_abi_size)) { const strat = try cg.moveStrategy(src_ty, src_rc, false); try strat.write(cg, try dst.tracking(cg).short.mem(cg, .{ - .size = cg.memSize(src_ty), + .size = cg.memSize(src_ty, src_rc), .disp = disp, }), registerAlias(src_reg, src_abi_size)); } else { @@ -182906,14 +183391,34 @@ const Temp = struct { .integer, .memory, .float, .float_combine => class_index + 1, .sse => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.sseup}) orelse classes.len, .x87 => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.x87up}) orelse classes.len, - .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable, + .sseup, + .x87up, + .none, + .win_i128, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => unreachable, }); const part_size = switch (class) { .integer, .sse, .memory => @min(8 * @as(u7, next_class_index - class_index), remaining_abi_size), .x87 => 16, .float => 4, .float_combine => 8, - .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable, + .sseup, + .x87up, + .none, + .win_i128, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => unreachable, }; try dst.writeReg(part_disp, switch (class) { .integer => .u64, @@ -182926,7 +183431,18 @@ const Temp = struct { .x87 => .f80, .float => .f32, .float_combine => .vector_2_f32, - .sseup, .x87up, .memory, .none, .win_i128, .integer_per_element => unreachable, + .sseup, + .x87up, + .memory, + .none, + .win_i128, + .integer_per_element, + .sse_per_element, + .sse_sse_x87_per_qword, + .sse_per_xword, + .sse_per_yword, + .sse_per_zword, + => unreachable, }, src_reg, cg); part_disp += part_size; remaining_abi_size -= part_size; @@ -187486,7 +188002,11 @@ const Temp = struct { .unreach, .dead, .indirect_load_frame, - .elementwise_args, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, .reserved_frame, .air_ref, => unreachable, @@ -190152,7 +190672,15 @@ const Select = struct { .lea_lazy_sym => |lazy_sym| .{ .imm = .{ .lazy_sym = lazy_sym } }, .lea_extern_func => |extern_func| .{ .imm = .{ .extern_func = extern_func } }, else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) }, - .lea_frame, .elementwise_args, .reserved_frame, .air_ref => unreachable, + .lea_frame, + .elementwise_gpr, + .elementwise_sse, + .xwordwise_sse, + .ywordwise_sse, + .zwordwise_sse, + .reserved_frame, + .air_ref, + => unreachable, }, 1...2 => |imm| switch (op.flags.base.ref.valueOf(s)) { inline .register_pair, .register_triple, .register_quadruple => |regs| .{ diff --git a/src/codegen/x86_64/abi.zig b/src/codegen/x86_64/abi.zig index d44c2a57c1b40989c0ede0df99fa9dd86cbe675a..e14a2c86deafda632f386619df3fbb264ea9c6fd 100644 --- a/src/codegen/x86_64/abi.zig +++ b/src/codegen/x86_64/abi.zig @@ -24,59 +24,36 @@ pub const Class = enum { float, /// A `Class.sse` containing two `f32`s. float_combine, - /// Clang passes each vector element in a separate `Class.integer`, but returns as `Class.memory`. + /// Clang passes each vector element in a separate `Class.integer`. integer_per_element, + /// Clang passes each vector element in a separate `Class.sse`. + sse_per_element, + /// Just complete insanity, idk what to say. + sse_sse_x87_per_qword, + /// Clang passes each 16 bytes in a separate `Class.sse`. + sse_per_xword, + /// Clang passes each 32 bytes in a separate `Class.sse`. + sse_per_yword, + /// Clang passes each 64 bytes in a separate `Class.sse`. + sse_per_zword, - pub const one_integer: [8]Class = .{ - .integer, .none, .none, .none, - .none, .none, .none, .none, - }; - pub const two_integers: [8]Class = .{ - .integer, .integer, .none, .none, - .none, .none, .none, .none, - }; - pub const three_integers: [8]Class = .{ - .integer, .integer, .integer, .none, - .none, .none, .none, .none, - }; - pub const four_integers: [8]Class = .{ - .integer, .integer, .integer, .integer, - .none, .none, .none, .none, - }; - pub const len_integers: [8]Class = .{ - .integer_per_element, .none, .none, .none, - .none, .none, .none, .none, - }; + pub const one_integer: [8]Class = .{ .integer, .none, .none, .none, .none, .none, .none, .none }; + pub const two_integers: [8]Class = .{ .integer, .integer, .none, .none, .none, .none, .none, .none }; + pub const three_integers: [8]Class = .{ .integer, .integer, .integer, .none, .none, .none, .none, .none }; + pub const four_integers: [8]Class = .{ .integer, .integer, .integer, .integer, .none, .none, .none, .none }; + pub const len_integers: [8]Class = .{ .integer_per_element, .none, .none, .none, .none, .none, .none, .none }; pub const @"f16" = @"f64"; - pub const @"f32": [8]Class = .{ - .float, .none, .none, .none, - .none, .none, .none, .none, - }; - pub const @"f64": [8]Class = .{ - .sse, .none, .none, .none, - .none, .none, .none, .none, - }; - pub const @"f80": [8]Class = .{ - .x87, .x87up, .none, .none, - .none, .none, .none, .none, - }; - pub const @"f128": [8]Class = .{ - .sse, .sseup, .none, .none, - .none, .none, .none, .none, - }; + pub const @"f32": [8]Class = .{ .float, .none, .none, .none, .none, .none, .none, .none }; + pub const @"f64": [8]Class = .{ .sse, .none, .none, .none, .none, .none, .none, .none }; + pub const @"f80": [8]Class = .{ .x87, .x87up, .none, .none, .none, .none, .none, .none }; + pub const @"f128": [8]Class = .{ .sse, .sseup, .none, .none, .none, .none, .none, .none }; /// COMPLEX_X87: This class consists of types that will be returned via the x87 /// FPU. - pub const complex_x87: [8]Class = .{ - .x87, .x87up, .x87, .x87up, - .none, .none, .none, .none, - }; + pub const complex_x87: [8]Class = .{ .x87, .x87up, .x87, .x87up, .none, .none, .none, .none }; - pub const stack: [8]Class = .{ - .memory, .none, .none, .none, - .none, .none, .none, .none, - }; + pub const stack: [8]Class = .{ .memory, .none, .none, .none, .none, .none, .none, .none }; pub fn isX87(class: Class) bool { return switch (class) { @@ -112,7 +89,7 @@ pub const Class = enum { pub const Context = enum { ret, arg, other }; -pub fn classifyWindows(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Context) Class { +pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Context) Class { // https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017 // "There's a strict one-to-one correspondence between a function call's arguments // and the registers used for those arguments. Any argument that doesn't fit in 8 @@ -121,7 +98,8 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont // "All floating point operations are done using the 16 XMM registers." // "Structs and unions of size 8, 16, 32, or 64 bits, and __m64 types, are passed // as if they were integers of the same size." - return switch (ty.zigTypeTag(zcu)) { + var ty = init_ty; + while (true) return switch (ty.zigTypeTag(zcu)) { .pointer, .int, .bool, @@ -148,15 +126,41 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont else => .memory, }, }, - .float => switch (ty.floatBits(target)) { 16, 32, 64 => .sse, 80 => .memory, 128 => if (ctx == .arg) .memory else .sse, else => unreachable, }, - .vector => .sse, - + .vector => { + const len = ty.vectorLen(zcu); + const elem_ty = ty.childType(zcu); + if (len == 1) { + ty = elem_ty; + continue; + } + const reg_size: u64, const split_class: Class = if (target.cpu.has(.x86, .avx512f)) + .{ 64, .sse_per_zword } + else if (target.cpu.has(.x86, .avx)) + .{ 32, .sse_per_yword } + else + .{ 16, .sse_per_xword }; + if (elem_ty.toIntern() == .bool_type) { + if (len > reg_size) return if (ctx == .arg) .integer_per_element else .memory; + return if (ctx == .arg) .memory else .sse; + } + const elem_size = elem_ty.abiSize(zcu); + const unaligned_size = elem_size * len; + if ((unaligned_size <= 8 or unaligned_size > reg_size) and !std.math.isPowerOfTwo(len)) { + if (ctx == .ret and len > Win64.c_abi_int_return_regs.len) return .memory; + if (!elem_ty.isRuntimeFloat()) return .integer_per_element; + if (ctx == .ret and len > 2 and elem_size == 8) return .sse_sse_x87_per_qword; + return .sse_per_element; + } + if (unaligned_size <= reg_size) return if (ctx == .arg) .memory else .sse; + if (ctx == .ret and unaligned_size > reg_size * Win64.c_abi_sse_return_regs.len) return .memory; + return split_class; + }, .type, .comptime_float, .comptime_int, @@ -206,60 +210,56 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont else => unreachable, }, .vector => { + const len = ty.vectorLen(zcu); + if (len == 0) return Class.one_integer; const elem_ty = ty.childType(zcu); - const bits = elem_ty.bitSize(zcu) * ty.arrayLen(zcu); if (elem_ty.toIntern() == .bool_type) { - if (bits <= 32) return Class.one_integer; - if (bits <= 64) return Class.f64; - if (ctx == .other) return Class.stack; - if (bits <= 128) return Class.len_integers; - if (bits <= 256 and target.cpu.has(.x86, .avx)) return Class.len_integers; - if (bits <= 512 and target.cpu.has(.x86, .avx512f)) return Class.len_integers; + if (len <= 32) return Class.one_integer; + if (len <= 64) return Class.f64; + if (ctx != .arg) return Class.stack; + if (len <= 128) return Class.len_integers; + if (len <= 256 and target.cpu.has(.x86, .avx)) return Class.len_integers; + if (len <= 512 and target.cpu.has(.x86, .avx512f)) return Class.len_integers; return Class.stack; } - if (elem_ty.isRuntimeFloat() and elem_ty.floatBits(target) == 80) { - if (bits <= 80 * 1) return Class.f80; - if (bits <= 80 * 2) return Class.complex_x87; + if (elem_ty.isRuntimeFloat() and elem_ty.floatBits(target) == 80) switch (len) { + 0 => unreachable, + 1 => return Class.f80, + 2 => return Class.complex_x87, + else => return Class.stack, + }; + const unaligned_size = elem_ty.abiSize(zcu) * len; + if (unaligned_size <= 4) return Class.one_integer; + if (ctx == .arg and unaligned_size == 8 * 1 * 1 and len == 1 and + elem_ty.isRuntimeFloat()) return Class.stack; // what + if (unaligned_size <= 8 * 1) return .{ .sse, .none, .none, .none, .none, .none, .none, .none }; + if (unaligned_size <= 8 * 2) return .{ .sse, .sseup, .none, .none, .none, .none, .none, .none }; + if (!target.cpu.has(.x86, .avx)) { + if (ctx == .ret) switch (unaligned_size) { + else => {}, + 8 * 3 => if (len == 3) return if (elem_ty.isRuntimeFloat()) .{ + .sse_sse_x87_per_qword, .none, .none, .none, .none, .none, .none, .none, // how + } else Class.len_integers, // why + 8 * 2 * 2, 8 * 2 * 4 => return .{ .sse_per_xword, .none, .none, .none, .none, .none, .none, .none }, + }; return Class.stack; } - if (bits <= 64 * 1) return .{ - .sse, .none, .none, .none, - .none, .none, .none, .none, - }; - if (bits <= 64 * 2) return .{ - .sse, .sseup, .none, .none, - .none, .none, .none, .none, - }; - if (ctx == .arg and !target.cpu.has(.x86, .avx)) return Class.stack; - if (bits <= 64 * 3) return .{ - .sse, .sseup, .sseup, .none, - .none, .none, .none, .none, - }; - if (bits <= 64 * 4) return .{ - .sse, .sseup, .sseup, .sseup, - .none, .none, .none, .none, - }; - if (ctx == .arg and !target.cpu.has(.x86, .avx512f)) return Class.stack; - if (bits <= 64 * 5) return .{ - .sse, .sseup, .sseup, .sseup, - .sseup, .none, .none, .none, - }; - if (bits <= 64 * 6) return .{ - .sse, .sseup, .sseup, .sseup, - .sseup, .sseup, .none, .none, - }; - if (bits <= 64 * 7) return .{ - .sse, .sseup, .sseup, .sseup, - .sseup, .sseup, .sseup, .none, - }; - if (bits <= 64 * 8 or (ctx == .ret and bits <= @as(u64, if (target.cpu.has(.x86, .avx512f)) - 64 * 32 - else if (target.cpu.has(.x86, .avx)) - 64 * 16 - else - 64 * 8))) return .{ - .sse, .sseup, .sseup, .sseup, - .sseup, .sseup, .sseup, .sseup, + if (unaligned_size <= 8 * 3) return .{ .sse, .sseup, .sseup, .none, .none, .none, .none, .none }; + if (unaligned_size <= 8 * 4) return .{ .sse, .sseup, .sseup, .sseup, .none, .none, .none, .none }; + if (!target.cpu.has(.x86, .avx512f)) { + if (ctx == .ret) switch (unaligned_size) { + else => {}, + 8 * 4 * 2, 8 * 4 * 4 => return .{ .sse_per_yword, .none, .none, .none, .none, .none, .none, .none }, + }; + return Class.stack; + } + if (unaligned_size <= 8 * 5) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .none, .none, .none }; + if (unaligned_size <= 8 * 6) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .none, .none }; + if (unaligned_size <= 8 * 7) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .none }; + if (unaligned_size <= 8 * 8) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup }; + if (ctx == .ret) switch (unaligned_size) { + else => {}, + 8 * 8 * 2, 8 * 8 * 4 => return .{ .sse_per_zword, .none, .none, .none, .none, .none, .none, .none }, }; return Class.stack; }, @@ -457,7 +457,7 @@ pub const SysV = struct { pub const c_abi_int_param_regs = [_]Register{ .rdi, .rsi, .rdx, .rcx, .r8, .r9 }; pub const c_abi_x87_param_regs = x87_regs[0..0]; pub const c_abi_sse_param_regs = sse_avx_regs[0..8]; - pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx }; + pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx, .rcx }; pub const c_abi_x87_return_regs = x87_regs[0..2]; pub const c_abi_sse_return_regs = sse_avx_regs[0..4]; }; @@ -474,9 +474,9 @@ pub const Win64 = struct { pub const c_abi_int_param_regs = [_]Register{ .rcx, .rdx, .r8, .r9 }; pub const c_abi_x87_param_regs = x87_regs[0..0]; pub const c_abi_sse_param_regs = sse_avx_regs[0..4]; - pub const c_abi_int_return_regs = [_]Register{.rax}; - pub const c_abi_x87_return_regs = x87_regs[0..0]; - pub const c_abi_sse_return_regs = sse_avx_regs[0..1]; + pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx, .rcx }; + pub const c_abi_x87_return_regs = x87_regs[0..1]; + pub const c_abi_sse_return_regs = sse_avx_regs[0..4]; }; pub fn getCalleePreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register { diff --git a/test/c_abi/cfuncs.c b/test/c_abi/cfuncs.c index fdf77d717f719f4b58540e1b9775f4cf1d7fe09e..271d16ba7586910805baf7c68a1c62a1c065bc73 100644 --- a/test/c_abi/cfuncs.c +++ b/test/c_abi/cfuncs.c @@ -13,7 +13,15 @@ static void assert_or_panic(bool ok) { } } -#if defined __powerpc__ && !defined _ARCH_PPC64 +#if defined(__mips64__) +# define ZIG_MIPS64 +#elif defined(__mips__) +# define ZIG_MIPS32 +#endif + +#if defined(_ARCH_PPC64) +# define ZIG_PPC64 +#elif defined(__powerpc__) # define ZIG_PPC32 #endif @@ -211,407 +219,84 @@ float complex zig_cmultf(float complex a, float complex b); double complex zig_cmultd(double complex a, double complex b); #endif -struct Struct_u8 { - uint8_t a; -}; - -struct Struct_u8 zig_ret_struct_u8(void); - -void zig_struct_u8(struct Struct_u8, size_t); - -struct Struct_u8 c_ret_struct_u8(void) { - return (struct Struct_u8){ .a = 4 }; -} - -void c_struct_u8(struct Struct_u8 s, size_t i) { - assert_or_panic(s.a == 5); - assert_or_panic(i == 6); -} - -struct Struct_u16 { - uint16_t a; -}; - -struct Struct_u16 zig_ret_struct_u16(void); - -void zig_struct_u16(struct Struct_u16, size_t); - -struct Struct_u16 c_ret_struct_u16(void) { - return (struct Struct_u16){ .a = 10 }; -} - -void c_struct_u16(struct Struct_u16 s, size_t i) { - assert_or_panic(s.a == 11); - assert_or_panic(i == 12); -} - -struct Struct_u32 { - uint32_t a; -}; - -struct Struct_u32 zig_ret_struct_u32(void); - -void zig_struct_u32(struct Struct_u32, size_t); - -struct Struct_u32 c_ret_struct_u32(void) { - return (struct Struct_u32){ .a = 16 }; -} - -void c_struct_u32(struct Struct_u32 s, size_t i) { - assert_or_panic(s.a == 17); - assert_or_panic(i == 18); -} - -struct Struct_u64 { - uint64_t a; -}; - -struct Struct_u64 zig_ret_struct_u64(void); - -void zig_struct_u64(struct Struct_u64, size_t); - -struct Struct_u64 c_ret_struct_u64(void) { - return (struct Struct_u64){ .a = 22 }; -} - -void c_struct_u64(struct Struct_u64 s, size_t i) { - assert_or_panic(s.a == 23); - assert_or_panic(i == 24); -} - -struct Struct_u64_u64 { - uint64_t a; - uint64_t b; -}; - -struct Struct_u64_u64 zig_ret_struct_u64_u64(void); - -void zig_struct_u64_u64_0(struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_1(size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); -void zig_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); - -struct Struct_u64_u64 c_ret_struct_u64_u64(void) { - return (struct Struct_u64_u64){ .a = 21, .b = 22 }; -} - -void c_struct_u64_u64_0(struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 23); - assert_or_panic(s.b == 24); - assert_or_panic(i == 1); -} -void c_struct_u64_u64_1(size_t a0, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 25); - assert_or_panic(s.b == 26); - assert_or_panic(i == 2); -} -void c_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 27); - assert_or_panic(s.b == 28); - assert_or_panic(i == 3); -} -void c_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 29); - assert_or_panic(s.b == 30); - assert_or_panic(i == 4); -} -void c_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 31); - assert_or_panic(s.b == 32); - assert_or_panic(i == 5); -} -void c_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 33); - assert_or_panic(s.b == 34); - assert_or_panic(i == 6); -} -void c_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 35); - assert_or_panic(s.b == 36); - assert_or_panic(i == 7); -} -void c_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 37); - assert_or_panic(s.b == 38); - assert_or_panic(i == 8); -} -void c_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) { - assert_or_panic(s.a == 39); - assert_or_panic(s.b == 40); - assert_or_panic(i == 9); -} - -struct Struct_f32 { - float a; -}; - -struct Struct_f32 zig_ret_struct_f32(void); - -void zig_struct_f32(struct Struct_f32); - -struct Struct_f32 c_ret_struct_f32(void) { - return (struct Struct_f32){ .a = 2.5f }; -} - -void c_struct_f32(struct Struct_f32 s) { - assert_or_panic(s.a == 2.5f); -} - -struct Struct_f64 { - double a; -}; - -struct Struct_f64 zig_ret_struct_f64(void); - -void zig_struct_f64(struct Struct_f64); - -struct Struct_f64 c_ret_struct_f64(void) { - return (struct Struct_f64){ .a = 2.5 }; -} - -void c_struct_f64(struct Struct_f64 s) { - assert_or_panic(s.a == 2.5); -} - -struct Struct_f32a8 { - alignas(8) float a; -}; - -struct Struct_f32a8 zig_ret_struct_f32a8(void); - -void zig_struct_f32a8(struct Struct_f32a8, float); - -struct Struct_f32a8 c_ret_struct_f32a8(void) { - return (struct Struct_f32a8){ .a = 4.125f }; -} - -void c_struct_f32a8(struct Struct_f32a8 s, float f) { - assert_or_panic(s.a == 5.375f); - assert_or_panic(f == 6.5f); -} - -struct Struct_f32a8_f32a8 { - alignas(8) float a; - alignas(8) float b; -}; - -struct Struct_f32a8_f32a8 zig_ret_struct_f32a8_f32a8(void); - -void zig_struct_f32a8_f32a8(struct Struct_f32a8_f32a8, float); - -struct Struct_f32a8_f32a8 c_ret_struct_f32a8_f32a8(void) { - return (struct Struct_f32a8_f32a8){ .a = 6.625f, .b = 7.875f }; -} - -void c_struct_f32a8_f32a8(struct Struct_f32a8_f32a8 s, float f) { - assert_or_panic(s.a == 8.0625f); - assert_or_panic(s.b == 9.1875f); - assert_or_panic(f == 10.5f); -} - -struct Struct_f32f32_f32 { - struct { - float b, c; - } a; - float d; -}; - -struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void); - -void zig_struct_f32f32_f32(struct Struct_f32f32_f32); - -struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) { - return (struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f }; -} - -void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) { - assert_or_panic(s.a.b == 1.0f); - assert_or_panic(s.a.c == 2.0f); - assert_or_panic(s.d == 3.0f); -} - -struct Struct_f32_f32f32 { - float a; - struct { - float c, d; - } b; -}; - -struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void); - -void zig_struct_f32_f32f32(struct Struct_f32_f32f32); - -struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) { - return (struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } }; -} - -void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) { - assert_or_panic(s.a == 1.0f); - assert_or_panic(s.b.c == 2.0f); - assert_or_panic(s.b.d == 3.0f); -} - -struct Struct_u32_Union_u32_u32u32 { - uint32_t a; - union { - struct { - uint32_t d, e; - } c; - } b; -}; - -struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void); - -void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32); - -struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) { - struct Struct_u32_Union_u32_u32u32 s; - s.a = 1; - s.b.c.d = 2; - s.b.c.e = 3; - return s; -} - -void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) { - assert_or_panic(s.a == 1); - assert_or_panic(s.b.c.d == 2); - assert_or_panic(s.b.c.e == 3); -} - -struct Struct_i32_i32 { - int32_t a; - int32_t b; -}; - -void zig_struct_i32_i32(struct Struct_i32_i32); - -struct BigStruct { - uint64_t a; - uint64_t b; - uint64_t c; - uint64_t d; - uint8_t e; -}; - -void zig_big_struct(struct BigStruct); - -union BigUnion { - struct BigStruct a; -}; - -void zig_big_union(union BigUnion); - -struct SmallStructInts { - uint8_t a; - uint8_t b; - uint8_t c; - uint8_t d; -}; - -void zig_small_struct_ints(struct SmallStructInts); -struct SmallStructInts zig_ret_small_struct_ints(); - -struct MedStructInts { - int32_t x; - int32_t y; - int32_t z; -}; - -void zig_med_struct_ints(struct MedStructInts); -struct MedStructInts zig_ret_med_struct_ints(); - -struct MedStructMixed { - uint32_t a; - float b; - float c; - uint32_t d; -}; - -void zig_med_struct_mixed(struct MedStructMixed); -struct MedStructMixed zig_ret_med_struct_mixed(); - -void zig_small_packed_struct(uint8_t); -#ifndef ZIG_NO_I128 -void zig_big_packed_struct(__int128); -#endif - -struct SplitStructInts { - uint64_t a; - uint8_t b; - uint32_t c; -}; -void zig_split_struct_ints(struct SplitStructInts); - -struct SplitStructMixed { - uint64_t a; - uint8_t b; - float c; -}; -void zig_split_struct_mixed(struct SplitStructMixed); -struct SplitStructMixed zig_ret_split_struct_mixed(); - -struct BigStruct zig_big_struct_both(struct BigStruct); - -typedef float Vector2Float __attribute__((ext_vector_type(2))); -typedef float Vector4Float __attribute__((ext_vector_type(4))); - -void c_vector_2_float(Vector2Float vec) { - assert_or_panic(vec[0] == 1.0); - assert_or_panic(vec[1] == 2.0); -} - -void c_vector_4_float(Vector4Float vec) { - assert_or_panic(vec[0] == 1.0); - assert_or_panic(vec[1] == 2.0); - assert_or_panic(vec[2] == 3.0); - assert_or_panic(vec[3] == 4.0); -} - -Vector2Float c_ret_vector_2_float(void) { - return (Vector2Float){ - 1.0, - 2.0, - }; -} -Vector4Float c_ret_vector_4_float(void) { - return (Vector4Float){ - 1.0, - 2.0, - 3.0, - 4.0, - }; -} - #if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32) || defined(__wasm__) -typedef bool Vector2Bool __attribute__((ext_vector_type(2))); -typedef bool Vector4Bool __attribute__((ext_vector_type(4))); -typedef bool Vector8Bool __attribute__((ext_vector_type(8))); -typedef bool Vector16Bool __attribute__((ext_vector_type(16))); -typedef bool Vector32Bool __attribute__((ext_vector_type(32))); -typedef bool Vector64Bool __attribute__((ext_vector_type(64))); -typedef bool Vector128Bool __attribute__((ext_vector_type(128))); -typedef bool Vector256Bool __attribute__((ext_vector_type(256))); -typedef bool Vector512Bool __attribute__((ext_vector_type(512))); +typedef bool Vector_2_bool __attribute__((ext_vector_type(2))); -void c_vector_2_bool(Vector2Bool vec) { +Vector_2_bool zig_ret_vector_2_bool(void); +void zig_vector_2_bool(Vector_2_bool vec); + +Vector_2_bool c_ret_vector_2_bool(void) { + return (Vector_2_bool){ + true, + false, + }; +} +void c_vector_2_bool(Vector_2_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == true); } +void c_test_vector_2_bool(void) { + Vector_2_bool vec = zig_ret_vector_2_bool(); + assert_or_panic(vec[0] == false); + assert_or_panic(vec[1] == false); + zig_vector_2_bool((Vector_2_bool){ + false, + true, + }); +} -void c_vector_4_bool(Vector4Bool vec) { +typedef bool Vector_4_bool __attribute__((ext_vector_type(4))); + +Vector_4_bool zig_ret_vector_4_bool(void); +void zig_vector_4_bool(Vector_4_bool vec); + +Vector_4_bool c_ret_vector_4_bool(void) { + return (Vector_4_bool){ + true, + false, + true, + false, + }; +} +void c_vector_4_bool(Vector_4_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == true); assert_or_panic(vec[2] == false); assert_or_panic(vec[3] == true); } +void c_test_vector_4_bool(void) { + Vector_4_bool vec = zig_ret_vector_4_bool(); + assert_or_panic(vec[0] == false); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == true); + assert_or_panic(vec[3] == true); + zig_vector_4_bool((Vector_4_bool){ + false, + false, + false, + false, + }); +} -void c_vector_8_bool(Vector8Bool vec) { +typedef bool Vector_8_bool __attribute__((ext_vector_type(8))); + +Vector_8_bool zig_ret_vector_8_bool(void); +void zig_vector_8_bool(Vector_8_bool vec); + +Vector_8_bool c_ret_vector_8_bool(void) { + return (Vector_8_bool){ + false, + true, + false, + false, + true, + false, + false, + true, + }; +} +void c_vector_8_bool(Vector_8_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == false); assert_or_panic(vec[2] == true); @@ -621,8 +306,54 @@ void c_vector_8_bool(Vector8Bool vec) { assert_or_panic(vec[6] == false); assert_or_panic(vec[7] == true); } +void c_test_vector_8_bool(void) { + Vector_8_bool vec = zig_ret_vector_8_bool(); + assert_or_panic(vec[0] == false); + assert_or_panic(vec[1] == false); + assert_or_panic(vec[2] == false); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == true); + assert_or_panic(vec[5] == false); + assert_or_panic(vec[6] == false); + assert_or_panic(vec[7] == false); + zig_vector_8_bool((Vector_8_bool){ + true, + true, + false, + true, + false, + true, + true, + false, + }); +} -void c_vector_16_bool(Vector16Bool vec) { +typedef bool Vector_16_bool __attribute__((ext_vector_type(16))); + +Vector_16_bool zig_ret_vector_16_bool(void); +void zig_vector_16_bool(Vector_16_bool vec); + +Vector_16_bool c_ret_vector_16_bool(void) { + return (Vector_16_bool){ + true, + true, + false, + false, + false, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + }; +} +void c_vector_16_bool(Vector_16_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == false); assert_or_panic(vec[2] == false); @@ -640,8 +371,86 @@ void c_vector_16_bool(Vector16Bool vec) { assert_or_panic(vec[14] == false); assert_or_panic(vec[15] == false); } +void c_test_vector_16_bool(void) { + Vector_16_bool vec = zig_ret_vector_16_bool(); + assert_or_panic(vec[0] == false); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == false); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == false); + assert_or_panic(vec[5] == true); + assert_or_panic(vec[6] == false); + assert_or_panic(vec[7] == false); + assert_or_panic(vec[8] == true); + assert_or_panic(vec[9] == false); + assert_or_panic(vec[10] == false); + assert_or_panic(vec[11] == false); + assert_or_panic(vec[12] == false); + assert_or_panic(vec[13] == true); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == false); + zig_vector_16_bool((Vector_16_bool){ + true, + false, + true, + true, + true, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + }); +} -void c_vector_32_bool(Vector32Bool vec) { +typedef bool Vector_32_bool __attribute__((ext_vector_type(32))); + +Vector_32_bool zig_ret_vector_32_bool(void); +void zig_vector_32_bool(Vector_32_bool vec); + +Vector_32_bool c_ret_vector_32_bool(void) { + return (Vector_32_bool){ + true, + false, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + true, + false, + false, + true, + false, + false, + false, + }; +} +void c_vector_32_bool(Vector_32_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == false); assert_or_panic(vec[2] == true); @@ -675,8 +484,150 @@ void c_vector_32_bool(Vector32Bool vec) { assert_or_panic(vec[30] == true); assert_or_panic(vec[31] == false); } +void c_test_vector_32_bool(void) { + Vector_32_bool vec = zig_ret_vector_32_bool(); + assert_or_panic(vec[0] == false); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == false); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == true); + assert_or_panic(vec[5] == false); + assert_or_panic(vec[6] == true); + assert_or_panic(vec[7] == true); + assert_or_panic(vec[8] == true); + assert_or_panic(vec[9] == true); + assert_or_panic(vec[10] == true); + assert_or_panic(vec[11] == true); + assert_or_panic(vec[12] == false); + assert_or_panic(vec[13] == false); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == false); + assert_or_panic(vec[16] == false); + assert_or_panic(vec[17] == false); + assert_or_panic(vec[18] == true); + assert_or_panic(vec[19] == true); + assert_or_panic(vec[20] == true); + assert_or_panic(vec[21] == false); + assert_or_panic(vec[22] == true); + assert_or_panic(vec[23] == false); + assert_or_panic(vec[24] == true); + assert_or_panic(vec[25] == false); + assert_or_panic(vec[26] == false); + assert_or_panic(vec[27] == true); + assert_or_panic(vec[28] == false); + assert_or_panic(vec[29] == false); + assert_or_panic(vec[30] == true); + assert_or_panic(vec[31] == true); + zig_vector_32_bool((Vector_32_bool){ + false, + false, + false, + true, + true, + false, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + }); +} -void c_vector_64_bool(Vector64Bool vec) { +typedef bool Vector_64_bool __attribute__((ext_vector_type(64))); + +Vector_64_bool zig_ret_vector_64_bool(void); +void zig_vector_64_bool(Vector_64_bool vec); + +Vector_64_bool c_ret_vector_64_bool(void) { + return (Vector_64_bool){ + false, + true, + false, + true, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + }; +} +void c_vector_64_bool(Vector_64_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == true); assert_or_panic(vec[2] == true); @@ -742,8 +693,278 @@ void c_vector_64_bool(Vector64Bool vec) { assert_or_panic(vec[62] == true); assert_or_panic(vec[63] == false); } +void c_test_vector_64_bool(void) { + Vector_64_bool vec = zig_ret_vector_64_bool(); + assert_or_panic(vec[0] == true); + assert_or_panic(vec[1] == false); + assert_or_panic(vec[2] == true); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == false); + assert_or_panic(vec[5] == true); + assert_or_panic(vec[6] == false); + assert_or_panic(vec[7] == true); + assert_or_panic(vec[8] == true); + assert_or_panic(vec[9] == false); + assert_or_panic(vec[10] == true); + assert_or_panic(vec[11] == false); + assert_or_panic(vec[12] == true); + assert_or_panic(vec[13] == false); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == true); + assert_or_panic(vec[16] == false); + assert_or_panic(vec[17] == false); + assert_or_panic(vec[18] == true); + assert_or_panic(vec[19] == true); + assert_or_panic(vec[20] == false); + assert_or_panic(vec[21] == false); + assert_or_panic(vec[22] == true); + assert_or_panic(vec[23] == false); + assert_or_panic(vec[24] == false); + assert_or_panic(vec[25] == true); + assert_or_panic(vec[26] == true); + assert_or_panic(vec[27] == true); + assert_or_panic(vec[28] == true); + assert_or_panic(vec[29] == true); + assert_or_panic(vec[30] == false); + assert_or_panic(vec[31] == false); + assert_or_panic(vec[32] == true); + assert_or_panic(vec[33] == true); + assert_or_panic(vec[34] == true); + assert_or_panic(vec[35] == true); + assert_or_panic(vec[36] == false); + assert_or_panic(vec[37] == true); + assert_or_panic(vec[38] == false); + assert_or_panic(vec[39] == true); + assert_or_panic(vec[40] == true); + assert_or_panic(vec[41] == true); + assert_or_panic(vec[42] == true); + assert_or_panic(vec[43] == true); + assert_or_panic(vec[44] == false); + assert_or_panic(vec[45] == false); + assert_or_panic(vec[46] == false); + assert_or_panic(vec[47] == true); + assert_or_panic(vec[48] == true); + assert_or_panic(vec[49] == true); + assert_or_panic(vec[50] == false); + assert_or_panic(vec[51] == true); + assert_or_panic(vec[52] == true); + assert_or_panic(vec[53] == true); + assert_or_panic(vec[54] == false); + assert_or_panic(vec[55] == false); + assert_or_panic(vec[56] == false); + assert_or_panic(vec[57] == true); + assert_or_panic(vec[58] == false); + assert_or_panic(vec[59] == false); + assert_or_panic(vec[60] == true); + assert_or_panic(vec[61] == false); + assert_or_panic(vec[62] == true); + assert_or_panic(vec[63] == false); + zig_vector_64_bool((Vector_64_bool){ + true, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + true, + false, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + true, + false, + false, + false, + false, + false, + true, + false, + false, + true, + true, + false, + false, + false, + true, + true, + true, + true, + }); +} -void c_vector_128_bool(Vector128Bool vec) { +typedef bool Vector_128_bool __attribute__((ext_vector_type(128))); + +Vector_128_bool zig_ret_vector_128_bool(void); +void zig_vector_128_bool(Vector_128_bool vec); + +Vector_128_bool c_ret_vector_128_bool(void) { + return (Vector_128_bool){ + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + true, + true, + false, + false, + false, + false, + true, + true, + true, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + true, + true, + false, + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + }; +} +void c_vector_128_bool(Vector_128_bool vec) { assert_or_panic(vec[0] == false); assert_or_panic(vec[1] == false); assert_or_panic(vec[2] == false); @@ -873,11 +1094,536 @@ void c_vector_128_bool(Vector128Bool vec) { assert_or_panic(vec[126] == true); assert_or_panic(vec[127] == true); } +void c_test_vector_128_bool(void) { + Vector_128_bool vec = zig_ret_vector_128_bool(); + assert_or_panic(vec[0] == true); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == false); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == false); + assert_or_panic(vec[5] == true); + assert_or_panic(vec[6] == true); + assert_or_panic(vec[7] == false); + assert_or_panic(vec[8] == false); + assert_or_panic(vec[9] == true); + assert_or_panic(vec[10] == false); + assert_or_panic(vec[11] == false); + assert_or_panic(vec[12] == false); + assert_or_panic(vec[13] == true); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == true); + assert_or_panic(vec[16] == true); + assert_or_panic(vec[17] == false); + assert_or_panic(vec[18] == false); + assert_or_panic(vec[19] == true); + assert_or_panic(vec[20] == true); + assert_or_panic(vec[21] == true); + assert_or_panic(vec[22] == true); + assert_or_panic(vec[23] == true); + assert_or_panic(vec[24] == false); + assert_or_panic(vec[25] == false); + assert_or_panic(vec[26] == true); + assert_or_panic(vec[27] == true); + assert_or_panic(vec[28] == true); + assert_or_panic(vec[29] == false); + assert_or_panic(vec[30] == false); + assert_or_panic(vec[31] == true); + assert_or_panic(vec[32] == true); + assert_or_panic(vec[33] == false); + assert_or_panic(vec[34] == true); + assert_or_panic(vec[35] == true); + assert_or_panic(vec[36] == true); + assert_or_panic(vec[37] == false); + assert_or_panic(vec[38] == true); + assert_or_panic(vec[39] == true); + assert_or_panic(vec[40] == true); + assert_or_panic(vec[41] == false); + assert_or_panic(vec[42] == true); + assert_or_panic(vec[43] == true); + assert_or_panic(vec[44] == false); + assert_or_panic(vec[45] == false); + assert_or_panic(vec[46] == false); + assert_or_panic(vec[47] == true); + assert_or_panic(vec[48] == false); + assert_or_panic(vec[49] == false); + assert_or_panic(vec[50] == false); + assert_or_panic(vec[51] == false); + assert_or_panic(vec[52] == true); + assert_or_panic(vec[53] == false); + assert_or_panic(vec[54] == true); + assert_or_panic(vec[55] == false); + assert_or_panic(vec[56] == true); + assert_or_panic(vec[57] == false); + assert_or_panic(vec[58] == false); + assert_or_panic(vec[59] == true); + assert_or_panic(vec[60] == true); + assert_or_panic(vec[61] == true); + assert_or_panic(vec[62] == true); + assert_or_panic(vec[63] == true); + assert_or_panic(vec[64] == false); + assert_or_panic(vec[65] == false); + assert_or_panic(vec[66] == false); + assert_or_panic(vec[67] == true); + assert_or_panic(vec[68] == true); + assert_or_panic(vec[69] == false); + assert_or_panic(vec[70] == true); + assert_or_panic(vec[71] == true); + assert_or_panic(vec[72] == false); + assert_or_panic(vec[73] == true); + assert_or_panic(vec[74] == true); + assert_or_panic(vec[75] == false); + assert_or_panic(vec[76] == false); + assert_or_panic(vec[77] == true); + assert_or_panic(vec[78] == false); + assert_or_panic(vec[79] == true); + assert_or_panic(vec[80] == false); + assert_or_panic(vec[81] == false); + assert_or_panic(vec[82] == true); + assert_or_panic(vec[83] == true); + assert_or_panic(vec[84] == false); + assert_or_panic(vec[85] == true); + assert_or_panic(vec[86] == false); + assert_or_panic(vec[87] == false); + assert_or_panic(vec[88] == true); + assert_or_panic(vec[89] == true); + assert_or_panic(vec[90] == true); + assert_or_panic(vec[91] == true); + assert_or_panic(vec[92] == true); + assert_or_panic(vec[93] == false); + assert_or_panic(vec[94] == false); + assert_or_panic(vec[95] == true); + assert_or_panic(vec[96] == false); + assert_or_panic(vec[97] == false); + assert_or_panic(vec[98] == true); + assert_or_panic(vec[99] == true); + assert_or_panic(vec[100] == true); + assert_or_panic(vec[101] == true); + assert_or_panic(vec[102] == true); + assert_or_panic(vec[103] == true); + assert_or_panic(vec[104] == true); + assert_or_panic(vec[105] == false); + assert_or_panic(vec[106] == false); + assert_or_panic(vec[107] == true); + assert_or_panic(vec[108] == false); + assert_or_panic(vec[109] == false); + assert_or_panic(vec[110] == true); + assert_or_panic(vec[111] == false); + assert_or_panic(vec[112] == false); + assert_or_panic(vec[113] == true); + assert_or_panic(vec[114] == false); + assert_or_panic(vec[115] == false); + assert_or_panic(vec[116] == false); + assert_or_panic(vec[117] == false); + assert_or_panic(vec[118] == false); + assert_or_panic(vec[119] == false); + assert_or_panic(vec[120] == true); + assert_or_panic(vec[121] == true); + assert_or_panic(vec[122] == true); + assert_or_panic(vec[123] == false); + assert_or_panic(vec[124] == true); + assert_or_panic(vec[125] == false); + assert_or_panic(vec[126] == false); + assert_or_panic(vec[127] == true); + zig_vector_128_bool((Vector_128_bool){ + true, + true, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + false, + true, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + true, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + }); +} +typedef bool Vector_256_bool __attribute__((ext_vector_type(256))); + +Vector_256_bool zig_ret_vector_256_bool(void); +void zig_vector_256_bool(Vector_256_bool vec); + +Vector_256_bool c_ret_vector_256_bool(void) { + return (Vector_256_bool){ + true, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + false, + true, + true, + false, + true, + false, + true, + true, + false, + false, + true, + true, + false, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + false, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + false, + true, + false, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + false, + false, + false, + }; +} // WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target. -#if !defined(__wasm__) - -void c_vector_256_bool(Vector256Bool vec) { +#ifndef __wasm__ +void c_vector_256_bool(Vector_256_bool vec) { assert_or_panic(vec[0] == false); assert_or_panic(vec[1] == true); assert_or_panic(vec[2] == true); @@ -1135,8 +1881,1049 @@ void c_vector_256_bool(Vector256Bool vec) { assert_or_panic(vec[254] == true); assert_or_panic(vec[255] == false); } +#endif +void c_test_vector_256_bool(void) { + Vector_256_bool vec = zig_ret_vector_256_bool(); + assert_or_panic(vec[0] == true); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == true); + assert_or_panic(vec[3] == false); + assert_or_panic(vec[4] == true); + assert_or_panic(vec[5] == false); + assert_or_panic(vec[6] == false); + assert_or_panic(vec[7] == true); + assert_or_panic(vec[8] == false); + assert_or_panic(vec[9] == false); + assert_or_panic(vec[10] == false); + assert_or_panic(vec[11] == false); + assert_or_panic(vec[12] == false); + assert_or_panic(vec[13] == false); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == false); + assert_or_panic(vec[16] == true); + assert_or_panic(vec[17] == false); + assert_or_panic(vec[18] == true); + assert_or_panic(vec[19] == false); + assert_or_panic(vec[20] == false); + assert_or_panic(vec[21] == true); + assert_or_panic(vec[22] == true); + assert_or_panic(vec[23] == false); + assert_or_panic(vec[24] == false); + assert_or_panic(vec[25] == true); + assert_or_panic(vec[26] == true); + assert_or_panic(vec[27] == false); + assert_or_panic(vec[28] == true); + assert_or_panic(vec[29] == true); + assert_or_panic(vec[30] == true); + assert_or_panic(vec[31] == false); + assert_or_panic(vec[32] == true); + assert_or_panic(vec[33] == false); + assert_or_panic(vec[34] == true); + assert_or_panic(vec[35] == false); + assert_or_panic(vec[36] == true); + assert_or_panic(vec[37] == false); + assert_or_panic(vec[38] == true); + assert_or_panic(vec[39] == false); + assert_or_panic(vec[40] == false); + assert_or_panic(vec[41] == false); + assert_or_panic(vec[42] == true); + assert_or_panic(vec[43] == true); + assert_or_panic(vec[44] == true); + assert_or_panic(vec[45] == false); + assert_or_panic(vec[46] == false); + assert_or_panic(vec[47] == false); + assert_or_panic(vec[48] == true); + assert_or_panic(vec[49] == false); + assert_or_panic(vec[50] == true); + assert_or_panic(vec[51] == false); + assert_or_panic(vec[52] == true); + assert_or_panic(vec[53] == false); + assert_or_panic(vec[54] == true); + assert_or_panic(vec[55] == true); + assert_or_panic(vec[56] == false); + assert_or_panic(vec[57] == false); + assert_or_panic(vec[58] == false); + assert_or_panic(vec[59] == true); + assert_or_panic(vec[60] == true); + assert_or_panic(vec[61] == true); + assert_or_panic(vec[62] == false); + assert_or_panic(vec[63] == true); + assert_or_panic(vec[64] == false); + assert_or_panic(vec[65] == true); + assert_or_panic(vec[66] == false); + assert_or_panic(vec[67] == true); + assert_or_panic(vec[68] == true); + assert_or_panic(vec[69] == false); + assert_or_panic(vec[70] == true); + assert_or_panic(vec[71] == false); + assert_or_panic(vec[72] == true); + assert_or_panic(vec[73] == true); + assert_or_panic(vec[74] == false); + assert_or_panic(vec[75] == false); + assert_or_panic(vec[76] == false); + assert_or_panic(vec[77] == false); + assert_or_panic(vec[78] == false); + assert_or_panic(vec[79] == false); + assert_or_panic(vec[80] == false); + assert_or_panic(vec[81] == false); + assert_or_panic(vec[82] == false); + assert_or_panic(vec[83] == true); + assert_or_panic(vec[84] == false); + assert_or_panic(vec[85] == false); + assert_or_panic(vec[86] == false); + assert_or_panic(vec[87] == true); + assert_or_panic(vec[88] == false); + assert_or_panic(vec[89] == true); + assert_or_panic(vec[90] == true); + assert_or_panic(vec[91] == false); + assert_or_panic(vec[92] == false); + assert_or_panic(vec[93] == true); + assert_or_panic(vec[94] == true); + assert_or_panic(vec[95] == false); + assert_or_panic(vec[96] == false); + assert_or_panic(vec[97] == true); + assert_or_panic(vec[98] == false); + assert_or_panic(vec[99] == false); + assert_or_panic(vec[100] == false); + assert_or_panic(vec[101] == false); + assert_or_panic(vec[102] == false); + assert_or_panic(vec[103] == false); + assert_or_panic(vec[104] == false); + assert_or_panic(vec[105] == true); + assert_or_panic(vec[106] == true); + assert_or_panic(vec[107] == false); + assert_or_panic(vec[108] == true); + assert_or_panic(vec[109] == false); + assert_or_panic(vec[110] == true); + assert_or_panic(vec[111] == true); + assert_or_panic(vec[112] == false); + assert_or_panic(vec[113] == false); + assert_or_panic(vec[114] == false); + assert_or_panic(vec[115] == false); + assert_or_panic(vec[116] == false); + assert_or_panic(vec[117] == false); + assert_or_panic(vec[118] == false); + assert_or_panic(vec[119] == true); + assert_or_panic(vec[120] == true); + assert_or_panic(vec[121] == true); + assert_or_panic(vec[122] == false); + assert_or_panic(vec[123] == true); + assert_or_panic(vec[124] == true); + assert_or_panic(vec[125] == false); + assert_or_panic(vec[126] == false); + assert_or_panic(vec[127] == true); + assert_or_panic(vec[128] == true); + assert_or_panic(vec[129] == true); + assert_or_panic(vec[130] == true); + assert_or_panic(vec[131] == true); + assert_or_panic(vec[132] == false); + assert_or_panic(vec[133] == true); + assert_or_panic(vec[134] == true); + assert_or_panic(vec[135] == false); + assert_or_panic(vec[136] == false); + assert_or_panic(vec[137] == true); + assert_or_panic(vec[138] == true); + assert_or_panic(vec[139] == false); + assert_or_panic(vec[140] == true); + assert_or_panic(vec[141] == false); + assert_or_panic(vec[142] == true); + assert_or_panic(vec[143] == false); + assert_or_panic(vec[144] == true); + assert_or_panic(vec[145] == true); + assert_or_panic(vec[146] == true); + assert_or_panic(vec[147] == true); + assert_or_panic(vec[148] == false); + assert_or_panic(vec[149] == false); + assert_or_panic(vec[150] == false); + assert_or_panic(vec[151] == true); + assert_or_panic(vec[152] == false); + assert_or_panic(vec[153] == true); + assert_or_panic(vec[154] == false); + assert_or_panic(vec[155] == true); + assert_or_panic(vec[156] == true); + assert_or_panic(vec[157] == false); + assert_or_panic(vec[158] == true); + assert_or_panic(vec[159] == true); + assert_or_panic(vec[160] == true); + assert_or_panic(vec[161] == true); + assert_or_panic(vec[162] == true); + assert_or_panic(vec[163] == false); + assert_or_panic(vec[164] == false); + assert_or_panic(vec[165] == true); + assert_or_panic(vec[166] == false); + assert_or_panic(vec[167] == true); + assert_or_panic(vec[168] == true); + assert_or_panic(vec[169] == true); + assert_or_panic(vec[170] == true); + assert_or_panic(vec[171] == false); + assert_or_panic(vec[172] == true); + assert_or_panic(vec[173] == true); + assert_or_panic(vec[174] == true); + assert_or_panic(vec[175] == true); + assert_or_panic(vec[176] == true); + assert_or_panic(vec[177] == true); + assert_or_panic(vec[178] == true); + assert_or_panic(vec[179] == false); + assert_or_panic(vec[180] == true); + assert_or_panic(vec[181] == false); + assert_or_panic(vec[182] == false); + assert_or_panic(vec[183] == false); + assert_or_panic(vec[184] == true); + assert_or_panic(vec[185] == false); + assert_or_panic(vec[186] == true); + assert_or_panic(vec[187] == true); + assert_or_panic(vec[188] == false); + assert_or_panic(vec[189] == true); + assert_or_panic(vec[190] == false); + assert_or_panic(vec[191] == true); + assert_or_panic(vec[192] == false); + assert_or_panic(vec[193] == true); + assert_or_panic(vec[194] == false); + assert_or_panic(vec[195] == false); + assert_or_panic(vec[196] == true); + assert_or_panic(vec[197] == true); + assert_or_panic(vec[198] == true); + assert_or_panic(vec[199] == true); + assert_or_panic(vec[200] == true); + assert_or_panic(vec[201] == true); + assert_or_panic(vec[202] == true); + assert_or_panic(vec[203] == false); + assert_or_panic(vec[204] == true); + assert_or_panic(vec[205] == false); + assert_or_panic(vec[206] == false); + assert_or_panic(vec[207] == true); + assert_or_panic(vec[208] == true); + assert_or_panic(vec[209] == false); + assert_or_panic(vec[210] == false); + assert_or_panic(vec[211] == false); + assert_or_panic(vec[212] == true); + assert_or_panic(vec[213] == true); + assert_or_panic(vec[214] == true); + assert_or_panic(vec[215] == false); + assert_or_panic(vec[216] == false); + assert_or_panic(vec[217] == true); + assert_or_panic(vec[218] == true); + assert_or_panic(vec[219] == true); + assert_or_panic(vec[220] == true); + assert_or_panic(vec[221] == false); + assert_or_panic(vec[222] == true); + assert_or_panic(vec[223] == false); + assert_or_panic(vec[224] == true); + assert_or_panic(vec[225] == true); + assert_or_panic(vec[226] == true); + assert_or_panic(vec[227] == false); + assert_or_panic(vec[228] == false); + assert_or_panic(vec[229] == false); + assert_or_panic(vec[230] == false); + assert_or_panic(vec[231] == false); + assert_or_panic(vec[232] == true); + assert_or_panic(vec[233] == true); + assert_or_panic(vec[234] == false); + assert_or_panic(vec[235] == false); + assert_or_panic(vec[236] == false); + assert_or_panic(vec[237] == true); + assert_or_panic(vec[238] == true); + assert_or_panic(vec[239] == false); + assert_or_panic(vec[240] == true); + assert_or_panic(vec[241] == true); + assert_or_panic(vec[242] == true); + assert_or_panic(vec[243] == false); + assert_or_panic(vec[244] == true); + assert_or_panic(vec[245] == true); + assert_or_panic(vec[246] == false); + assert_or_panic(vec[247] == true); + assert_or_panic(vec[248] == false); + assert_or_panic(vec[249] == false); + assert_or_panic(vec[250] == true); + assert_or_panic(vec[251] == true); + assert_or_panic(vec[252] == false); + assert_or_panic(vec[253] == true); + assert_or_panic(vec[254] == false); + assert_or_panic(vec[255] == true); + zig_vector_256_bool((Vector_256_bool){ + false, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + false, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + false, + false, + true, + false, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + false, + false, + false, + false, + false, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + false, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + false, + false, + true, + true, + true, + true, + }); +} -void c_vector_512_bool(Vector512Bool vec) { +typedef bool Vector_512_bool __attribute__((ext_vector_type(512))); + +Vector_512_bool zig_ret_vector_512_bool(void); +void zig_vector_512_bool(Vector_512_bool vec); + +Vector_512_bool c_ret_vector_512_bool(void) { + return (Vector_512_bool){ + false, + true, + false, + false, + false, + true, + false, + false, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + true, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + false, + false, + true, + true, + false, + false, + false, + true, + false, + true, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + false, + true, + false, + true, + false, + false, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + true, + true, + false, + true, + false, + false, + false, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + false, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + false, + true, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + true, + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + true, + false, + true, + false, + }; +} +// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target. +#ifndef __wasm__ +void c_vector_512_bool(Vector_512_bool vec) { assert_or_panic(vec[0] == true); assert_or_panic(vec[1] == true); assert_or_panic(vec[2] == true); @@ -1650,43 +3437,531 @@ void c_vector_512_bool(Vector512Bool vec) { assert_or_panic(vec[510] == false); assert_or_panic(vec[511] == true); } - #endif - -Vector2Bool c_ret_vector_2_bool(void) { - return (Vector2Bool){ - true, +void c_test_vector_512_bool(void) { + Vector_512_bool vec = zig_ret_vector_512_bool(); + assert_or_panic(vec[0] == true); + assert_or_panic(vec[1] == true); + assert_or_panic(vec[2] == true); + assert_or_panic(vec[3] == true); + assert_or_panic(vec[4] == false); + assert_or_panic(vec[5] == true); + assert_or_panic(vec[6] == false); + assert_or_panic(vec[7] == true); + assert_or_panic(vec[8] == true); + assert_or_panic(vec[9] == true); + assert_or_panic(vec[10] == false); + assert_or_panic(vec[11] == true); + assert_or_panic(vec[12] == false); + assert_or_panic(vec[13] == false); + assert_or_panic(vec[14] == false); + assert_or_panic(vec[15] == true); + assert_or_panic(vec[16] == true); + assert_or_panic(vec[17] == false); + assert_or_panic(vec[18] == false); + assert_or_panic(vec[19] == false); + assert_or_panic(vec[20] == true); + assert_or_panic(vec[21] == true); + assert_or_panic(vec[22] == false); + assert_or_panic(vec[23] == false); + assert_or_panic(vec[24] == false); + assert_or_panic(vec[25] == false); + assert_or_panic(vec[26] == true); + assert_or_panic(vec[27] == false); + assert_or_panic(vec[28] == false); + assert_or_panic(vec[29] == false); + assert_or_panic(vec[30] == true); + assert_or_panic(vec[31] == true); + assert_or_panic(vec[32] == true); + assert_or_panic(vec[33] == true); + assert_or_panic(vec[34] == false); + assert_or_panic(vec[35] == false); + assert_or_panic(vec[36] == false); + assert_or_panic(vec[37] == true); + assert_or_panic(vec[38] == true); + assert_or_panic(vec[39] == true); + assert_or_panic(vec[40] == false); + assert_or_panic(vec[41] == false); + assert_or_panic(vec[42] == true); + assert_or_panic(vec[43] == false); + assert_or_panic(vec[44] == false); + assert_or_panic(vec[45] == true); + assert_or_panic(vec[46] == false); + assert_or_panic(vec[47] == false); + assert_or_panic(vec[48] == true); + assert_or_panic(vec[49] == true); + assert_or_panic(vec[50] == true); + assert_or_panic(vec[51] == true); + assert_or_panic(vec[52] == false); + assert_or_panic(vec[53] == false); + assert_or_panic(vec[54] == false); + assert_or_panic(vec[55] == true); + assert_or_panic(vec[56] == false); + assert_or_panic(vec[57] == true); + assert_or_panic(vec[58] == false); + assert_or_panic(vec[59] == true); + assert_or_panic(vec[60] == true); + assert_or_panic(vec[61] == false); + assert_or_panic(vec[62] == false); + assert_or_panic(vec[63] == true); + assert_or_panic(vec[64] == true); + assert_or_panic(vec[65] == false); + assert_or_panic(vec[66] == true); + assert_or_panic(vec[67] == false); + assert_or_panic(vec[68] == false); + assert_or_panic(vec[69] == false); + assert_or_panic(vec[70] == true); + assert_or_panic(vec[71] == true); + assert_or_panic(vec[72] == true); + assert_or_panic(vec[73] == true); + assert_or_panic(vec[74] == true); + assert_or_panic(vec[75] == false); + assert_or_panic(vec[76] == true); + assert_or_panic(vec[77] == false); + assert_or_panic(vec[78] == true); + assert_or_panic(vec[79] == true); + assert_or_panic(vec[80] == true); + assert_or_panic(vec[81] == true); + assert_or_panic(vec[82] == true); + assert_or_panic(vec[83] == false); + assert_or_panic(vec[84] == true); + assert_or_panic(vec[85] == true); + assert_or_panic(vec[86] == false); + assert_or_panic(vec[87] == true); + assert_or_panic(vec[88] == false); + assert_or_panic(vec[89] == false); + assert_or_panic(vec[90] == true); + assert_or_panic(vec[91] == false); + assert_or_panic(vec[92] == true); + assert_or_panic(vec[93] == false); + assert_or_panic(vec[94] == false); + assert_or_panic(vec[95] == false); + assert_or_panic(vec[96] == true); + assert_or_panic(vec[97] == true); + assert_or_panic(vec[98] == false); + assert_or_panic(vec[99] == true); + assert_or_panic(vec[100] == true); + assert_or_panic(vec[101] == false); + assert_or_panic(vec[102] == true); + assert_or_panic(vec[103] == false); + assert_or_panic(vec[104] == true); + assert_or_panic(vec[105] == false); + assert_or_panic(vec[106] == true); + assert_or_panic(vec[107] == false); + assert_or_panic(vec[108] == false); + assert_or_panic(vec[109] == true); + assert_or_panic(vec[110] == false); + assert_or_panic(vec[111] == false); + assert_or_panic(vec[112] == true); + assert_or_panic(vec[113] == false); + assert_or_panic(vec[114] == true); + assert_or_panic(vec[115] == false); + assert_or_panic(vec[116] == true); + assert_or_panic(vec[117] == false); + assert_or_panic(vec[118] == false); + assert_or_panic(vec[119] == true); + assert_or_panic(vec[120] == true); + assert_or_panic(vec[121] == true); + assert_or_panic(vec[122] == false); + assert_or_panic(vec[123] == true); + assert_or_panic(vec[124] == false); + assert_or_panic(vec[125] == false); + assert_or_panic(vec[126] == true); + assert_or_panic(vec[127] == true); + assert_or_panic(vec[128] == false); + assert_or_panic(vec[129] == true); + assert_or_panic(vec[130] == true); + assert_or_panic(vec[131] == false); + assert_or_panic(vec[132] == true); + assert_or_panic(vec[133] == true); + assert_or_panic(vec[134] == false); + assert_or_panic(vec[135] == true); + assert_or_panic(vec[136] == true); + assert_or_panic(vec[137] == false); + assert_or_panic(vec[138] == false); + assert_or_panic(vec[139] == false); + assert_or_panic(vec[140] == true); + assert_or_panic(vec[141] == false); + assert_or_panic(vec[142] == true); + assert_or_panic(vec[143] == false); + assert_or_panic(vec[144] == false); + assert_or_panic(vec[145] == false); + assert_or_panic(vec[146] == true); + assert_or_panic(vec[147] == false); + assert_or_panic(vec[148] == true); + assert_or_panic(vec[149] == false); + assert_or_panic(vec[150] == false); + assert_or_panic(vec[151] == true); + assert_or_panic(vec[152] == false); + assert_or_panic(vec[153] == true); + assert_or_panic(vec[154] == true); + assert_or_panic(vec[155] == false); + assert_or_panic(vec[156] == true); + assert_or_panic(vec[157] == true); + assert_or_panic(vec[158] == false); + assert_or_panic(vec[159] == true); + assert_or_panic(vec[160] == true); + assert_or_panic(vec[161] == false); + assert_or_panic(vec[162] == false); + assert_or_panic(vec[163] == false); + assert_or_panic(vec[164] == true); + assert_or_panic(vec[165] == false); + assert_or_panic(vec[166] == true); + assert_or_panic(vec[167] == true); + assert_or_panic(vec[168] == true); + assert_or_panic(vec[169] == true); + assert_or_panic(vec[170] == false); + assert_or_panic(vec[171] == true); + assert_or_panic(vec[172] == false); + assert_or_panic(vec[173] == false); + assert_or_panic(vec[174] == true); + assert_or_panic(vec[175] == true); + assert_or_panic(vec[176] == true); + assert_or_panic(vec[177] == false); + assert_or_panic(vec[178] == false); + assert_or_panic(vec[179] == false); + assert_or_panic(vec[180] == true); + assert_or_panic(vec[181] == false); + assert_or_panic(vec[182] == false); + assert_or_panic(vec[183] == true); + assert_or_panic(vec[184] == true); + assert_or_panic(vec[185] == false); + assert_or_panic(vec[186] == true); + assert_or_panic(vec[187] == false); + assert_or_panic(vec[188] == true); + assert_or_panic(vec[189] == true); + assert_or_panic(vec[190] == true); + assert_or_panic(vec[191] == true); + assert_or_panic(vec[192] == true); + assert_or_panic(vec[193] == true); + assert_or_panic(vec[194] == true); + assert_or_panic(vec[195] == false); + assert_or_panic(vec[196] == false); + assert_or_panic(vec[197] == false); + assert_or_panic(vec[198] == false); + assert_or_panic(vec[199] == false); + assert_or_panic(vec[200] == true); + assert_or_panic(vec[201] == false); + assert_or_panic(vec[202] == true); + assert_or_panic(vec[203] == false); + assert_or_panic(vec[204] == true); + assert_or_panic(vec[205] == true); + assert_or_panic(vec[206] == false); + assert_or_panic(vec[207] == false); + assert_or_panic(vec[208] == false); + assert_or_panic(vec[209] == true); + assert_or_panic(vec[210] == true); + assert_or_panic(vec[211] == true); + assert_or_panic(vec[212] == false); + assert_or_panic(vec[213] == false); + assert_or_panic(vec[214] == true); + assert_or_panic(vec[215] == true); + assert_or_panic(vec[216] == true); + assert_or_panic(vec[217] == false); + assert_or_panic(vec[218] == false); + assert_or_panic(vec[219] == true); + assert_or_panic(vec[220] == false); + assert_or_panic(vec[221] == true); + assert_or_panic(vec[222] == true); + assert_or_panic(vec[223] == false); + assert_or_panic(vec[224] == true); + assert_or_panic(vec[225] == false); + assert_or_panic(vec[226] == false); + assert_or_panic(vec[227] == true); + assert_or_panic(vec[228] == false); + assert_or_panic(vec[229] == false); + assert_or_panic(vec[230] == true); + assert_or_panic(vec[231] == true); + assert_or_panic(vec[232] == false); + assert_or_panic(vec[233] == true); + assert_or_panic(vec[234] == true); + assert_or_panic(vec[235] == true); + assert_or_panic(vec[236] == true); + assert_or_panic(vec[237] == true); + assert_or_panic(vec[238] == false); + assert_or_panic(vec[239] == true); + assert_or_panic(vec[240] == false); + assert_or_panic(vec[241] == false); + assert_or_panic(vec[242] == true); + assert_or_panic(vec[243] == false); + assert_or_panic(vec[244] == true); + assert_or_panic(vec[245] == false); + assert_or_panic(vec[246] == true); + assert_or_panic(vec[247] == false); + assert_or_panic(vec[248] == true); + assert_or_panic(vec[249] == true); + assert_or_panic(vec[250] == true); + assert_or_panic(vec[251] == true); + assert_or_panic(vec[252] == true); + assert_or_panic(vec[253] == false); + assert_or_panic(vec[254] == false); + assert_or_panic(vec[255] == false); + assert_or_panic(vec[256] == false); + assert_or_panic(vec[257] == false); + assert_or_panic(vec[258] == false); + assert_or_panic(vec[259] == true); + assert_or_panic(vec[260] == true); + assert_or_panic(vec[261] == true); + assert_or_panic(vec[262] == true); + assert_or_panic(vec[263] == false); + assert_or_panic(vec[264] == false); + assert_or_panic(vec[265] == false); + assert_or_panic(vec[266] == true); + assert_or_panic(vec[267] == false); + assert_or_panic(vec[268] == true); + assert_or_panic(vec[269] == false); + assert_or_panic(vec[270] == true); + assert_or_panic(vec[271] == true); + assert_or_panic(vec[272] == true); + assert_or_panic(vec[273] == true); + assert_or_panic(vec[274] == true); + assert_or_panic(vec[275] == true); + assert_or_panic(vec[276] == false); + assert_or_panic(vec[277] == false); + assert_or_panic(vec[278] == true); + assert_or_panic(vec[279] == true); + assert_or_panic(vec[280] == false); + assert_or_panic(vec[281] == false); + assert_or_panic(vec[282] == false); + assert_or_panic(vec[283] == false); + assert_or_panic(vec[284] == true); + assert_or_panic(vec[285] == true); + assert_or_panic(vec[286] == true); + assert_or_panic(vec[287] == false); + assert_or_panic(vec[288] == false); + assert_or_panic(vec[289] == false); + assert_or_panic(vec[290] == true); + assert_or_panic(vec[291] == false); + assert_or_panic(vec[292] == true); + assert_or_panic(vec[293] == true); + assert_or_panic(vec[294] == false); + assert_or_panic(vec[295] == true); + assert_or_panic(vec[296] == true); + assert_or_panic(vec[297] == true); + assert_or_panic(vec[298] == false); + assert_or_panic(vec[299] == true); + assert_or_panic(vec[300] == true); + assert_or_panic(vec[301] == false); + assert_or_panic(vec[302] == false); + assert_or_panic(vec[303] == true); + assert_or_panic(vec[304] == false); + assert_or_panic(vec[305] == false); + assert_or_panic(vec[306] == true); + assert_or_panic(vec[307] == true); + assert_or_panic(vec[308] == true); + assert_or_panic(vec[309] == true); + assert_or_panic(vec[310] == false); + assert_or_panic(vec[311] == false); + assert_or_panic(vec[312] == false); + assert_or_panic(vec[313] == false); + assert_or_panic(vec[314] == false); + assert_or_panic(vec[315] == true); + assert_or_panic(vec[316] == false); + assert_or_panic(vec[317] == false); + assert_or_panic(vec[318] == true); + assert_or_panic(vec[319] == false); + assert_or_panic(vec[320] == false); + assert_or_panic(vec[321] == true); + assert_or_panic(vec[322] == true); + assert_or_panic(vec[323] == true); + assert_or_panic(vec[324] == true); + assert_or_panic(vec[325] == false); + assert_or_panic(vec[326] == false); + assert_or_panic(vec[327] == false); + assert_or_panic(vec[328] == true); + assert_or_panic(vec[329] == true); + assert_or_panic(vec[330] == false); + assert_or_panic(vec[331] == true); + assert_or_panic(vec[332] == true); + assert_or_panic(vec[333] == false); + assert_or_panic(vec[334] == false); + assert_or_panic(vec[335] == true); + assert_or_panic(vec[336] == true); + assert_or_panic(vec[337] == false); + assert_or_panic(vec[338] == true); + assert_or_panic(vec[339] == true); + assert_or_panic(vec[340] == true); + assert_or_panic(vec[341] == false); + assert_or_panic(vec[342] == false); + assert_or_panic(vec[343] == false); + assert_or_panic(vec[344] == true); + assert_or_panic(vec[345] == true); + assert_or_panic(vec[346] == false); + assert_or_panic(vec[347] == true); + assert_or_panic(vec[348] == false); + assert_or_panic(vec[349] == true); + assert_or_panic(vec[350] == false); + assert_or_panic(vec[351] == false); + assert_or_panic(vec[352] == true); + assert_or_panic(vec[353] == false); + assert_or_panic(vec[354] == true); + assert_or_panic(vec[355] == false); + assert_or_panic(vec[356] == false); + assert_or_panic(vec[357] == false); + assert_or_panic(vec[358] == false); + assert_or_panic(vec[359] == false); + assert_or_panic(vec[360] == true); + assert_or_panic(vec[361] == true); + assert_or_panic(vec[362] == false); + assert_or_panic(vec[363] == false); + assert_or_panic(vec[364] == false); + assert_or_panic(vec[365] == false); + assert_or_panic(vec[366] == true); + assert_or_panic(vec[367] == false); + assert_or_panic(vec[368] == true); + assert_or_panic(vec[369] == false); + assert_or_panic(vec[370] == true); + assert_or_panic(vec[371] == true); + assert_or_panic(vec[372] == false); + assert_or_panic(vec[373] == true); + assert_or_panic(vec[374] == true); + assert_or_panic(vec[375] == true); + assert_or_panic(vec[376] == true); + assert_or_panic(vec[377] == true); + assert_or_panic(vec[378] == false); + assert_or_panic(vec[379] == true); + assert_or_panic(vec[380] == false); + assert_or_panic(vec[381] == true); + assert_or_panic(vec[382] == true); + assert_or_panic(vec[383] == true); + assert_or_panic(vec[384] == true); + assert_or_panic(vec[385] == true); + assert_or_panic(vec[386] == false); + assert_or_panic(vec[387] == true); + assert_or_panic(vec[388] == true); + assert_or_panic(vec[389] == false); + assert_or_panic(vec[390] == true); + assert_or_panic(vec[391] == false); + assert_or_panic(vec[392] == true); + assert_or_panic(vec[393] == false); + assert_or_panic(vec[394] == true); + assert_or_panic(vec[395] == false); + assert_or_panic(vec[396] == true); + assert_or_panic(vec[397] == false); + assert_or_panic(vec[398] == false); + assert_or_panic(vec[399] == true); + assert_or_panic(vec[400] == true); + assert_or_panic(vec[401] == true); + assert_or_panic(vec[402] == true); + assert_or_panic(vec[403] == false); + assert_or_panic(vec[404] == false); + assert_or_panic(vec[405] == true); + assert_or_panic(vec[406] == false); + assert_or_panic(vec[407] == false); + assert_or_panic(vec[408] == false); + assert_or_panic(vec[409] == true); + assert_or_panic(vec[410] == false); + assert_or_panic(vec[411] == true); + assert_or_panic(vec[412] == true); + assert_or_panic(vec[413] == false); + assert_or_panic(vec[414] == true); + assert_or_panic(vec[415] == true); + assert_or_panic(vec[416] == false); + assert_or_panic(vec[417] == true); + assert_or_panic(vec[418] == true); + assert_or_panic(vec[419] == false); + assert_or_panic(vec[420] == false); + assert_or_panic(vec[421] == true); + assert_or_panic(vec[422] == false); + assert_or_panic(vec[423] == false); + assert_or_panic(vec[424] == true); + assert_or_panic(vec[425] == false); + assert_or_panic(vec[426] == true); + assert_or_panic(vec[427] == false); + assert_or_panic(vec[428] == false); + assert_or_panic(vec[429] == true); + assert_or_panic(vec[430] == false); + assert_or_panic(vec[431] == true); + assert_or_panic(vec[432] == true); + assert_or_panic(vec[433] == false); + assert_or_panic(vec[434] == true); + assert_or_panic(vec[435] == false); + assert_or_panic(vec[436] == true); + assert_or_panic(vec[437] == false); + assert_or_panic(vec[438] == true); + assert_or_panic(vec[439] == false); + assert_or_panic(vec[440] == false); + assert_or_panic(vec[441] == true); + assert_or_panic(vec[442] == true); + assert_or_panic(vec[443] == false); + assert_or_panic(vec[444] == true); + assert_or_panic(vec[445] == true); + assert_or_panic(vec[446] == false); + assert_or_panic(vec[447] == true); + assert_or_panic(vec[448] == true); + assert_or_panic(vec[449] == false); + assert_or_panic(vec[450] == false); + assert_or_panic(vec[451] == false); + assert_or_panic(vec[452] == false); + assert_or_panic(vec[453] == false); + assert_or_panic(vec[454] == true); + assert_or_panic(vec[455] == false); + assert_or_panic(vec[456] == false); + assert_or_panic(vec[457] == true); + assert_or_panic(vec[458] == false); + assert_or_panic(vec[459] == true); + assert_or_panic(vec[460] == false); + assert_or_panic(vec[461] == false); + assert_or_panic(vec[462] == false); + assert_or_panic(vec[463] == true); + assert_or_panic(vec[464] == false); + assert_or_panic(vec[465] == true); + assert_or_panic(vec[466] == false); + assert_or_panic(vec[467] == false); + assert_or_panic(vec[468] == false); + assert_or_panic(vec[469] == false); + assert_or_panic(vec[470] == true); + assert_or_panic(vec[471] == true); + assert_or_panic(vec[472] == false); + assert_or_panic(vec[473] == true); + assert_or_panic(vec[474] == true); + assert_or_panic(vec[475] == false); + assert_or_panic(vec[476] == false); + assert_or_panic(vec[477] == true); + assert_or_panic(vec[478] == true); + assert_or_panic(vec[479] == true); + assert_or_panic(vec[480] == false); + assert_or_panic(vec[481] == false); + assert_or_panic(vec[482] == true); + assert_or_panic(vec[483] == false); + assert_or_panic(vec[484] == false); + assert_or_panic(vec[485] == false); + assert_or_panic(vec[486] == true); + assert_or_panic(vec[487] == true); + assert_or_panic(vec[488] == false); + assert_or_panic(vec[489] == false); + assert_or_panic(vec[490] == false); + assert_or_panic(vec[491] == false); + assert_or_panic(vec[492] == false); + assert_or_panic(vec[493] == true); + assert_or_panic(vec[494] == true); + assert_or_panic(vec[495] == true); + assert_or_panic(vec[496] == true); + assert_or_panic(vec[497] == false); + assert_or_panic(vec[498] == false); + assert_or_panic(vec[499] == false); + assert_or_panic(vec[500] == true); + assert_or_panic(vec[501] == false); + assert_or_panic(vec[502] == true); + assert_or_panic(vec[503] == true); + assert_or_panic(vec[504] == true); + assert_or_panic(vec[505] == true); + assert_or_panic(vec[506] == false); + assert_or_panic(vec[507] == false); + assert_or_panic(vec[508] == true); + assert_or_panic(vec[509] == true); + assert_or_panic(vec[510] == false); + assert_or_panic(vec[511] == false); + zig_vector_512_bool((Vector_512_bool){ false, - }; -} - -Vector4Bool c_ret_vector_4_bool(void) { - return (Vector4Bool){ true, - false, true, false, - }; -} - -Vector8Bool c_ret_vector_8_bool(void) { - return (Vector8Bool){ - false, true, false, - false, true, false, false, - true, - }; -} - -Vector16Bool c_ret_vector_16_bool(void) { - return (Vector16Bool){ - true, - true, - false, false, false, false, @@ -1695,68 +3970,49 @@ Vector16Bool c_ret_vector_16_bool(void) { true, false, false, - true, - true, false, true, true, - }; -} - -Vector32Bool c_ret_vector_32_bool(void) { - return (Vector32Bool){ - true, - false, - true, true, true, false, - true, false, - true, - true, - true, false, true, true, false, - false, + true, true, false, false, - false, - false, - true, true, true, false, - true, false, false, - true, false, false, false, - }; -} - -Vector64Bool c_ret_vector_64_bool(void) { - return (Vector64Bool){ false, true, + true, + true, false, true, true, true, - false, true, true, + false, true, true, true, + false, true, false, + false, true, + false, true, true, false, @@ -1764,35 +4020,36 @@ Vector64Bool c_ret_vector_64_bool(void) { false, true, true, - false, true, - false, true, false, - true, false, true, + true, false, true, + true, false, false, true, - true, false, false, false, true, true, true, - true, false, false, + true, false, true, + false, + false, true, false, false, true, + true, false, false, false, @@ -1801,76 +4058,68 @@ Vector64Bool c_ret_vector_64_bool(void) { false, false, false, + false, + false, + false, true, true, true, true, true, - }; -} - -Vector128Bool c_ret_vector_128_bool(void) { - return (Vector128Bool){ false, - true, - true, false, - true, false, false, true, true, false, true, - false, - false, - false, - true, - false, true, false, false, true, false, - true, false, false, false, true, true, true, + true, false, false, false, false, true, - true, - true, - false, - true, - true, false, false, false, false, true, true, + false, true, false, + true, false, false, + true, + true, false, true, + true, false, false, - true, false, + true, false, false, false, false, true, true, + false, + false, true, false, true, @@ -1881,12 +4130,6 @@ Vector128Bool c_ret_vector_128_bool(void) { false, false, false, - false, - false, - true, - true, - true, - true, true, false, false, @@ -1896,41 +4139,35 @@ Vector128Bool c_ret_vector_128_bool(void) { false, true, false, - true, false, - true, false, - true, false, true, - true, - true, - true, false, false, - true, false, false, - true, + false, + false, true, true, true, false, true, true, - true, false, false, - true, + false, false, false, true, true, false, - true, + false, false, true, - true, + false, + false, true, true, true, @@ -1939,53 +4176,39 @@ Vector128Bool c_ret_vector_128_bool(void) { true, false, true, - }; -} - -Vector256Bool c_ret_vector_256_bool(void) { - return (Vector256Bool){ true, - false, true, true, false, - false, + true, false, false, false, true, false, - true, false, - true, false, false, - true, - true, - true, false, false, false, true, false, - true, false, false, true, true, true, - false, - false, - true, - true, true, false, true, true, - true, + false, + false, false, true, false, + false, true, true, false, @@ -1995,38 +4218,33 @@ Vector256Bool c_ret_vector_256_bool(void) { true, false, false, - true, - true, false, false, true, false, true, true, - true, false, - true, - true, false, true, true, + true, false, true, false, + false, true, true, + false, true, false, true, true, - false, true, true, true, true, - false, true, - false, true, true, true, @@ -2035,23 +4253,22 @@ Vector256Bool c_ret_vector_256_bool(void) { false, true, false, - false, + true, true, false, + true, false, + true, false, true, true, false, - false, - false, true, true, true, false, false, false, - true, false, true, true, @@ -2061,24 +4278,17 @@ Vector256Bool c_ret_vector_256_bool(void) { true, true, true, - false, true, false, true, false, false, true, - true, - false, - true, - false, false, false, false, - true, false, false, - true, false, false, false, @@ -2086,22 +4296,12 @@ Vector256Bool c_ret_vector_256_bool(void) { false, false, true, - false, true, false, - true, - true, - true, false, - true, - true, false, - true, - true, false, - true, - true, - true, + false, true, true, true, @@ -2109,18 +4309,19 @@ Vector256Bool c_ret_vector_256_bool(void) { false, false, false, + false, + true, true, false, false, - true, false, true, true, - true, false, false, - true, - true, + false, + false, + false, true, true, false, @@ -2128,19 +4329,19 @@ Vector256Bool c_ret_vector_256_bool(void) { true, false, true, - false, - false, + true, false, true, true, + false, true, true, + false, true, + false, true, true, true, - false, - false, true, false, false, @@ -2149,20 +4350,15 @@ Vector256Bool c_ret_vector_256_bool(void) { true, true, true, - true, - true, - false, - false, false, true, true, true, false, - true, false, true, false, - true, + false, false, true, true, @@ -2170,53 +4366,28 @@ Vector256Bool c_ret_vector_256_bool(void) { false, true, false, - true, false, - true, false, true, false, false, true, - false, true, true, - false, - false, true, false, - false, - false, true, true, false, false, false, - false, - false, - true, - false, true, - false, - false, - false, - }; -} - -Vector512Bool c_ret_vector_512_bool(void) { - return (Vector512Bool){ false, true, - false, - false, - false, true, false, false, false, - true, - false, - false, false, true, false, @@ -2225,46 +4396,34 @@ Vector512Bool c_ret_vector_512_bool(void) { false, false, false, - false, - false, - true, true, false, false, - false, - false, true, true, - false, true, false, true, true, - true, - false, false, true, + false, true, false, false, false, + true, false, false, - true, false, true, true, - false, - true, true, true, true, false, false, false, - true, - true, - false, false, false, false, @@ -2274,44 +4433,26 @@ Vector512Bool c_ret_vector_512_bool(void) { true, true, false, - false, - false, - false, - false, - true, - false, - true, - false, - false, true, true, false, - false, - false, true, false, true, - true, - true, false, true, false, false, - true, - true, false, true, - true, false, - true, false, - true, - true, false, true, true, false, false, + true, false, true, false, @@ -2320,459 +4461,10843 @@ Vector512Bool c_ret_vector_512_bool(void) { true, true, true, - false, true, false, - true, false, true, - true, - false, - true, - false, - true, - true, - true, - false, - true, - false, - false, - false, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - false, - true, - false, - true, - false, - false, - true, - false, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - true, - true, - false, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - true, - false, - false, - false, - false, - true, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - true, - false, - false, - true, - true, - true, - false, - false, - false, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - true, - false, - true, - true, - true, - false, - false, - true, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - true, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - false, - true, - false, - true, - true, - false, - false, - true, - false, - false, - true, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - false, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - false, - false, - false, - true, - true, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - true, - true, - false, - true, - true, - true, - false, - true, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - true, - false, - true, - false, + }); +} + +#endif + +typedef uint8_t Vector_1_u8 __attribute__((vector_size(1 * sizeof(uint8_t)))); + +Vector_1_u8 zig_ret_vector_1_u8(void); +void zig_vector_1_u8(Vector_1_u8, size_t); + +Vector_1_u8 c_ret_vector_1_u8(void) { + return (Vector_1_u8){ 3 }; +} +void c_vector_1_u8(Vector_1_u8 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_u8(void) { + Vector_1_u8 v = zig_ret_vector_1_u8(); + assert_or_panic(v[0] == 1); + zig_vector_1_u8((Vector_1_u8){ 2 }, 1); +} + +typedef uint8_t Vector_2_u8 __attribute__((vector_size(2 * sizeof(uint8_t)))); + +Vector_2_u8 zig_ret_vector_2_u8(void); +void zig_vector_2_u8(Vector_2_u8, size_t); + +Vector_2_u8 c_ret_vector_2_u8(void) { + return (Vector_2_u8){ 9, 10 }; +} +void c_vector_2_u8(Vector_2_u8 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_u8(void) { + Vector_2_u8 v = zig_ret_vector_2_u8(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_u8((Vector_2_u8){ 7, 8 }, 2); +} + +typedef uint8_t Vector_3_u8 __attribute__((vector_size(3 * sizeof(uint8_t)))); + +Vector_3_u8 zig_ret_vector_3_u8(void); +void zig_vector_3_u8(Vector_3_u8, size_t); + +Vector_3_u8 c_ret_vector_3_u8(void) { + return (Vector_3_u8){ 19, 20, 21 }; +} +void c_vector_3_u8(Vector_3_u8 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 3); +} +void c_test_vector_3_u8(void) { + Vector_3_u8 v = zig_ret_vector_3_u8(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_u8((Vector_3_u8){ 16, 17, 18 }, 3); +} + +typedef uint8_t Vector_4_u8 __attribute__((vector_size(4 * sizeof(uint8_t)))); + +Vector_4_u8 zig_ret_vector_4_u8(void); +void zig_vector_4_u8(Vector_4_u8, size_t); +void zig_vector_4_u8_vector_4_u8(Vector_4_u8, Vector_4_u8, size_t); + +Vector_4_u8 c_ret_vector_4_u8(void) { + return (Vector_4_u8){ 41, 42, 43, 44 }; +} +void c_vector_4_u8(Vector_4_u8 v, size_t i) { + assert_or_panic(v[0] == 45); + assert_or_panic(v[1] == 46); + assert_or_panic(v[2] == 47); + assert_or_panic(v[3] == 48); + assert_or_panic(i == 4); +} +void c_vector_4_u8_vector_4_u8(Vector_4_u8 v0, Vector_4_u8 v1, size_t i) { + assert_or_panic(v0[0] == 49); + assert_or_panic(v0[1] == 50); + assert_or_panic(v0[2] == 51); + assert_or_panic(v0[3] == 52); + assert_or_panic(v1[0] == 53); + assert_or_panic(v1[1] == 54); + assert_or_panic(v1[2] == 55); + assert_or_panic(v1[3] == 56); + assert_or_panic(i == 8); +} +void c_test_vector_4_u8(void) { + Vector_4_u8 v = zig_ret_vector_4_u8(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_u8((Vector_4_u8){ 29, 30, 31, 32 }, 4); + zig_vector_4_u8_vector_4_u8((Vector_4_u8){ 33, 34, 35, 36 }, (Vector_4_u8){ 37, 38, 39, 40 }, 8); +} + +typedef uint8_t Vector_6_u8 __attribute__((vector_size(6 * sizeof(uint8_t)))); + +Vector_6_u8 zig_ret_vector_6_u8(void); +void zig_vector_6_u8(Vector_6_u8, size_t); + +Vector_6_u8 c_ret_vector_6_u8(void) { + return (Vector_6_u8){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_u8(Vector_6_u8 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_u8(void) { + Vector_6_u8 v = zig_ret_vector_6_u8(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_u8((Vector_6_u8){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef uint8_t Vector_8_u8 __attribute__((vector_size(8 * sizeof(uint8_t)))); + +Vector_8_u8 zig_ret_vector_8_u8(void); +void zig_vector_8_u8(Vector_8_u8, size_t); + +Vector_8_u8 c_ret_vector_8_u8(void) { + return (Vector_8_u8){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_u8(Vector_8_u8 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_u8(void) { + Vector_8_u8 v = zig_ret_vector_8_u8(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_u8((Vector_8_u8){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef uint8_t Vector_12_u8 __attribute__((vector_size(12 * sizeof(uint8_t)))); + +Vector_12_u8 zig_ret_vector_12_u8(void); +void zig_vector_12_u8(Vector_12_u8, size_t); + +Vector_12_u8 c_ret_vector_12_u8(void) { + return (Vector_12_u8){ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 }; +} +void c_vector_12_u8(Vector_12_u8 v, size_t i) { + assert_or_panic(v[0] == 33); + assert_or_panic(v[1] == 34); + assert_or_panic(v[2] == 35); + assert_or_panic(v[3] == 36); + assert_or_panic(v[4] == 37); + assert_or_panic(v[5] == 38); + assert_or_panic(v[6] == 39); + assert_or_panic(v[7] == 40); + assert_or_panic(v[8] == 41); + assert_or_panic(v[9] == 42); + assert_or_panic(v[10] == 43); + assert_or_panic(v[11] == 44); + assert_or_panic(i == 12); +} +void c_test_vector_12_u8(void) { + Vector_12_u8 v = zig_ret_vector_12_u8(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 0); + assert_or_panic(v[4] == 1); + assert_or_panic(v[5] == 2); + assert_or_panic(v[6] == 3); + assert_or_panic(v[7] == 4); + assert_or_panic(v[8] == 5); + assert_or_panic(v[9] == 6); + assert_or_panic(v[10] == 7); + assert_or_panic(v[11] == 8); + zig_vector_12_u8((Vector_12_u8){ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }, 12); +} + +typedef uint8_t Vector_16_u8 __attribute__((vector_size(16 * sizeof(uint8_t)))); + +Vector_16_u8 zig_ret_vector_16_u8(void); +void zig_vector_16_u8(Vector_16_u8, size_t); + +Vector_16_u8 c_ret_vector_16_u8(void) { + return (Vector_16_u8){ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92 }; +} +void c_vector_16_u8(Vector_16_u8 v, size_t i) { + assert_or_panic(v[0] == 93); + assert_or_panic(v[1] == 94); + assert_or_panic(v[2] == 95); + assert_or_panic(v[3] == 96); + assert_or_panic(v[4] == 97); + assert_or_panic(v[5] == 98); + assert_or_panic(v[6] == 99); + assert_or_panic(v[7] == 0); + assert_or_panic(v[8] == 1); + assert_or_panic(v[9] == 2); + assert_or_panic(v[10] == 3); + assert_or_panic(v[11] == 4); + assert_or_panic(v[12] == 5); + assert_or_panic(v[13] == 6); + assert_or_panic(v[14] == 7); + assert_or_panic(v[15] == 8); + assert_or_panic(i == 16); +} +void c_test_vector_16_u8(void) { + Vector_16_u8 v = zig_ret_vector_16_u8(); + assert_or_panic(v[0] == 45); + assert_or_panic(v[1] == 46); + assert_or_panic(v[2] == 47); + assert_or_panic(v[3] == 48); + assert_or_panic(v[4] == 49); + assert_or_panic(v[5] == 50); + assert_or_panic(v[6] == 51); + assert_or_panic(v[7] == 52); + assert_or_panic(v[8] == 53); + assert_or_panic(v[9] == 54); + assert_or_panic(v[10] == 55); + assert_or_panic(v[11] == 56); + assert_or_panic(v[12] == 57); + assert_or_panic(v[13] == 58); + assert_or_panic(v[14] == 59); + assert_or_panic(v[15] == 60); + zig_vector_16_u8((Vector_16_u8){ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 }, 16); +} + +typedef uint8_t Vector_24_u8 __attribute__((vector_size(24 * sizeof(uint8_t)))); + +Vector_24_u8 zig_ret_vector_24_u8(void); +void zig_vector_24_u8(Vector_24_u8, size_t); + +Vector_24_u8 c_ret_vector_24_u8(void) { + return (Vector_24_u8){ + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, + }; +} +void c_vector_24_u8(Vector_24_u8 v, size_t i) { + assert_or_panic(v[0] == 81); + assert_or_panic(v[1] == 82); + assert_or_panic(v[2] == 83); + assert_or_panic(v[3] == 84); + assert_or_panic(v[4] == 85); + assert_or_panic(v[5] == 86); + assert_or_panic(v[6] == 87); + assert_or_panic(v[7] == 88); + assert_or_panic(v[8] == 89); + assert_or_panic(v[9] == 90); + assert_or_panic(v[10] == 91); + assert_or_panic(v[11] == 92); + assert_or_panic(v[12] == 93); + assert_or_panic(v[13] == 94); + assert_or_panic(v[14] == 95); + assert_or_panic(v[15] == 96); + assert_or_panic(v[16] == 97); + assert_or_panic(v[17] == 98); + assert_or_panic(v[18] == 99); + assert_or_panic(v[19] == 0); + assert_or_panic(v[20] == 1); + assert_or_panic(v[21] == 2); + assert_or_panic(v[22] == 3); + assert_or_panic(v[23] == 4); + assert_or_panic(i == 24); +} +void c_test_vector_24_u8(void) { + Vector_24_u8 v = zig_ret_vector_24_u8(); + assert_or_panic(v[0] == 9); + assert_or_panic(v[1] == 10); + assert_or_panic(v[2] == 11); + assert_or_panic(v[3] == 12); + assert_or_panic(v[4] == 13); + assert_or_panic(v[5] == 14); + assert_or_panic(v[6] == 15); + assert_or_panic(v[7] == 16); + assert_or_panic(v[8] == 17); + assert_or_panic(v[9] == 18); + assert_or_panic(v[10] == 19); + assert_or_panic(v[11] == 20); + assert_or_panic(v[12] == 21); + assert_or_panic(v[13] == 22); + assert_or_panic(v[14] == 23); + assert_or_panic(v[15] == 24); + assert_or_panic(v[16] == 25); + assert_or_panic(v[17] == 26); + assert_or_panic(v[18] == 27); + assert_or_panic(v[19] == 28); + assert_or_panic(v[20] == 29); + assert_or_panic(v[21] == 30); + assert_or_panic(v[22] == 31); + assert_or_panic(v[23] == 32); + zig_vector_24_u8((Vector_24_u8){ + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, + }, 24); +} + +typedef uint8_t Vector_32_u8 __attribute__((vector_size(32 * sizeof(uint8_t)))); + +Vector_32_u8 zig_ret_vector_32_u8(void); +void zig_vector_32_u8(Vector_32_u8, size_t); + +Vector_32_u8 c_ret_vector_32_u8(void) { + return (Vector_32_u8){ + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, + }; +} +void c_vector_32_u8(Vector_32_u8 v, size_t i) { + assert_or_panic(v[0] == 1); + assert_or_panic(v[1] == 2); + assert_or_panic(v[2] == 3); + assert_or_panic(v[3] == 4); + assert_or_panic(v[4] == 5); + assert_or_panic(v[5] == 6); + assert_or_panic(v[6] == 7); + assert_or_panic(v[7] == 8); + assert_or_panic(v[8] == 9); + assert_or_panic(v[9] == 10); + assert_or_panic(v[10] == 11); + assert_or_panic(v[11] == 12); + assert_or_panic(v[12] == 13); + assert_or_panic(v[13] == 14); + assert_or_panic(v[14] == 15); + assert_or_panic(v[15] == 16); + assert_or_panic(v[16] == 17); + assert_or_panic(v[17] == 18); + assert_or_panic(v[18] == 19); + assert_or_panic(v[19] == 20); + assert_or_panic(v[20] == 21); + assert_or_panic(v[21] == 22); + assert_or_panic(v[22] == 23); + assert_or_panic(v[23] == 24); + assert_or_panic(v[24] == 25); + assert_or_panic(v[25] == 26); + assert_or_panic(v[26] == 27); + assert_or_panic(v[27] == 28); + assert_or_panic(v[28] == 29); + assert_or_panic(v[29] == 30); + assert_or_panic(v[30] == 31); + assert_or_panic(v[31] == 32); + assert_or_panic(i == 32); +} +void c_test_vector_32_u8(void) { + Vector_32_u8 v = zig_ret_vector_32_u8(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + assert_or_panic(v[2] == 7); + assert_or_panic(v[3] == 8); + assert_or_panic(v[4] == 9); + assert_or_panic(v[5] == 10); + assert_or_panic(v[6] == 11); + assert_or_panic(v[7] == 12); + assert_or_panic(v[8] == 13); + assert_or_panic(v[9] == 14); + assert_or_panic(v[10] == 15); + assert_or_panic(v[11] == 16); + assert_or_panic(v[12] == 17); + assert_or_panic(v[13] == 18); + assert_or_panic(v[14] == 19); + assert_or_panic(v[15] == 20); + assert_or_panic(v[16] == 21); + assert_or_panic(v[17] == 22); + assert_or_panic(v[18] == 23); + assert_or_panic(v[19] == 24); + assert_or_panic(v[20] == 25); + assert_or_panic(v[21] == 26); + assert_or_panic(v[22] == 27); + assert_or_panic(v[23] == 28); + assert_or_panic(v[24] == 29); + assert_or_panic(v[25] == 30); + assert_or_panic(v[26] == 31); + assert_or_panic(v[27] == 32); + assert_or_panic(v[28] == 33); + assert_or_panic(v[29] == 34); + assert_or_panic(v[30] == 35); + assert_or_panic(v[31] == 36); + zig_vector_32_u8((Vector_32_u8){ + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + }, 32); +} + +typedef uint8_t Vector_48_u8 __attribute__((vector_size(48 * sizeof(uint8_t)))); + +Vector_48_u8 zig_ret_vector_48_u8(void); +void zig_vector_48_u8(Vector_48_u8, size_t); + +Vector_48_u8 c_ret_vector_48_u8(void) { + return (Vector_48_u8){ + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + }; +} +void c_vector_48_u8(Vector_48_u8 v, size_t i) { + assert_or_panic(v[0] == 77); + assert_or_panic(v[1] == 78); + assert_or_panic(v[2] == 79); + assert_or_panic(v[3] == 80); + assert_or_panic(v[4] == 81); + assert_or_panic(v[5] == 82); + assert_or_panic(v[6] == 83); + assert_or_panic(v[7] == 84); + assert_or_panic(v[8] == 85); + assert_or_panic(v[9] == 86); + assert_or_panic(v[10] == 87); + assert_or_panic(v[11] == 88); + assert_or_panic(v[12] == 89); + assert_or_panic(v[13] == 90); + assert_or_panic(v[14] == 91); + assert_or_panic(v[15] == 92); + assert_or_panic(v[16] == 93); + assert_or_panic(v[17] == 94); + assert_or_panic(v[18] == 95); + assert_or_panic(v[19] == 96); + assert_or_panic(v[20] == 97); + assert_or_panic(v[21] == 98); + assert_or_panic(v[22] == 99); + assert_or_panic(v[23] == 0); + assert_or_panic(v[24] == 1); + assert_or_panic(v[25] == 2); + assert_or_panic(v[26] == 3); + assert_or_panic(v[27] == 4); + assert_or_panic(v[28] == 5); + assert_or_panic(v[29] == 6); + assert_or_panic(v[30] == 7); + assert_or_panic(v[31] == 8); + assert_or_panic(v[32] == 9); + assert_or_panic(v[33] == 10); + assert_or_panic(v[34] == 11); + assert_or_panic(v[35] == 12); + assert_or_panic(v[36] == 13); + assert_or_panic(v[37] == 14); + assert_or_panic(v[38] == 15); + assert_or_panic(v[39] == 16); + assert_or_panic(v[40] == 17); + assert_or_panic(v[41] == 18); + assert_or_panic(v[42] == 19); + assert_or_panic(v[43] == 20); + assert_or_panic(v[44] == 21); + assert_or_panic(v[45] == 22); + assert_or_panic(v[46] == 23); + assert_or_panic(v[47] == 24); + assert_or_panic(i == 48); +} +void c_test_vector_48_u8(void) { + Vector_48_u8 v = zig_ret_vector_48_u8(); + assert_or_panic(v[0] == 33); + assert_or_panic(v[1] == 34); + assert_or_panic(v[2] == 35); + assert_or_panic(v[3] == 36); + assert_or_panic(v[4] == 37); + assert_or_panic(v[5] == 38); + assert_or_panic(v[6] == 39); + assert_or_panic(v[7] == 40); + assert_or_panic(v[8] == 41); + assert_or_panic(v[9] == 42); + assert_or_panic(v[10] == 43); + assert_or_panic(v[11] == 44); + assert_or_panic(v[12] == 45); + assert_or_panic(v[13] == 46); + assert_or_panic(v[14] == 47); + assert_or_panic(v[15] == 48); + assert_or_panic(v[16] == 49); + assert_or_panic(v[17] == 50); + assert_or_panic(v[18] == 51); + assert_or_panic(v[19] == 52); + assert_or_panic(v[20] == 53); + assert_or_panic(v[21] == 54); + assert_or_panic(v[22] == 55); + assert_or_panic(v[23] == 56); + assert_or_panic(v[24] == 57); + assert_or_panic(v[25] == 58); + assert_or_panic(v[26] == 59); + assert_or_panic(v[27] == 60); + assert_or_panic(v[28] == 61); + assert_or_panic(v[29] == 62); + assert_or_panic(v[30] == 63); + assert_or_panic(v[31] == 64); + assert_or_panic(v[32] == 65); + assert_or_panic(v[33] == 66); + assert_or_panic(v[34] == 67); + assert_or_panic(v[35] == 68); + assert_or_panic(v[36] == 69); + assert_or_panic(v[37] == 70); + assert_or_panic(v[38] == 71); + assert_or_panic(v[39] == 72); + assert_or_panic(v[40] == 73); + assert_or_panic(v[41] == 74); + assert_or_panic(v[42] == 75); + assert_or_panic(v[43] == 76); + assert_or_panic(v[44] == 77); + assert_or_panic(v[45] == 78); + assert_or_panic(v[46] == 79); + assert_or_panic(v[47] == 80); + zig_vector_48_u8((Vector_48_u8){ + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + }, 48); +} + +typedef uint8_t Vector_64_u8 __attribute__((vector_size(64 * sizeof(uint8_t)))); + +Vector_64_u8 zig_ret_vector_64_u8(void); +void zig_vector_64_u8(Vector_64_u8, size_t); + +Vector_64_u8 c_ret_vector_64_u8(void) { + return (Vector_64_u8){ + 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + }; +} +void c_vector_64_u8(Vector_64_u8 v, size_t i) { + assert_or_panic(v[0] == 17); + assert_or_panic(v[1] == 18); + assert_or_panic(v[2] == 19); + assert_or_panic(v[3] == 20); + assert_or_panic(v[4] == 21); + assert_or_panic(v[5] == 22); + assert_or_panic(v[6] == 23); + assert_or_panic(v[7] == 24); + assert_or_panic(v[8] == 25); + assert_or_panic(v[9] == 26); + assert_or_panic(v[10] == 27); + assert_or_panic(v[11] == 28); + assert_or_panic(v[12] == 29); + assert_or_panic(v[13] == 30); + assert_or_panic(v[14] == 31); + assert_or_panic(v[15] == 32); + assert_or_panic(v[16] == 33); + assert_or_panic(v[17] == 34); + assert_or_panic(v[18] == 35); + assert_or_panic(v[19] == 36); + assert_or_panic(v[20] == 37); + assert_or_panic(v[21] == 38); + assert_or_panic(v[22] == 39); + assert_or_panic(v[23] == 40); + assert_or_panic(v[24] == 41); + assert_or_panic(v[25] == 42); + assert_or_panic(v[26] == 43); + assert_or_panic(v[27] == 44); + assert_or_panic(v[28] == 45); + assert_or_panic(v[29] == 46); + assert_or_panic(v[30] == 47); + assert_or_panic(v[31] == 48); + assert_or_panic(v[32] == 49); + assert_or_panic(v[33] == 50); + assert_or_panic(v[34] == 51); + assert_or_panic(v[35] == 52); + assert_or_panic(v[36] == 53); + assert_or_panic(v[37] == 54); + assert_or_panic(v[38] == 55); + assert_or_panic(v[39] == 56); + assert_or_panic(v[40] == 57); + assert_or_panic(v[41] == 58); + assert_or_panic(v[42] == 59); + assert_or_panic(v[43] == 60); + assert_or_panic(v[44] == 61); + assert_or_panic(v[45] == 62); + assert_or_panic(v[46] == 63); + assert_or_panic(v[47] == 64); + assert_or_panic(v[48] == 65); + assert_or_panic(v[49] == 66); + assert_or_panic(v[50] == 67); + assert_or_panic(v[51] == 68); + assert_or_panic(v[52] == 69); + assert_or_panic(v[53] == 70); + assert_or_panic(v[54] == 71); + assert_or_panic(v[55] == 72); + assert_or_panic(v[56] == 73); + assert_or_panic(v[57] == 74); + assert_or_panic(v[58] == 75); + assert_or_panic(v[59] == 76); + assert_or_panic(v[60] == 77); + assert_or_panic(v[61] == 78); + assert_or_panic(v[62] == 79); + assert_or_panic(v[63] == 80); + assert_or_panic(i == 64); +} +void c_test_vector_64_u8(void) { + Vector_64_u8 v = zig_ret_vector_64_u8(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + assert_or_panic(v[4] == 29); + assert_or_panic(v[5] == 30); + assert_or_panic(v[6] == 31); + assert_or_panic(v[7] == 32); + assert_or_panic(v[8] == 33); + assert_or_panic(v[9] == 34); + assert_or_panic(v[10] == 35); + assert_or_panic(v[11] == 36); + assert_or_panic(v[12] == 37); + assert_or_panic(v[13] == 38); + assert_or_panic(v[14] == 39); + assert_or_panic(v[15] == 40); + assert_or_panic(v[16] == 41); + assert_or_panic(v[17] == 42); + assert_or_panic(v[18] == 43); + assert_or_panic(v[19] == 44); + assert_or_panic(v[20] == 45); + assert_or_panic(v[21] == 46); + assert_or_panic(v[22] == 47); + assert_or_panic(v[23] == 48); + assert_or_panic(v[24] == 49); + assert_or_panic(v[25] == 50); + assert_or_panic(v[26] == 51); + assert_or_panic(v[27] == 52); + assert_or_panic(v[28] == 53); + assert_or_panic(v[29] == 54); + assert_or_panic(v[30] == 55); + assert_or_panic(v[31] == 56); + assert_or_panic(v[32] == 57); + assert_or_panic(v[33] == 58); + assert_or_panic(v[34] == 59); + assert_or_panic(v[35] == 60); + assert_or_panic(v[36] == 61); + assert_or_panic(v[37] == 62); + assert_or_panic(v[38] == 63); + assert_or_panic(v[39] == 64); + assert_or_panic(v[40] == 65); + assert_or_panic(v[41] == 66); + assert_or_panic(v[42] == 67); + assert_or_panic(v[43] == 68); + assert_or_panic(v[44] == 69); + assert_or_panic(v[45] == 70); + assert_or_panic(v[46] == 71); + assert_or_panic(v[47] == 72); + assert_or_panic(v[48] == 73); + assert_or_panic(v[49] == 74); + assert_or_panic(v[50] == 75); + assert_or_panic(v[51] == 76); + assert_or_panic(v[52] == 77); + assert_or_panic(v[53] == 78); + assert_or_panic(v[54] == 79); + assert_or_panic(v[55] == 80); + assert_or_panic(v[56] == 81); + assert_or_panic(v[57] == 82); + assert_or_panic(v[58] == 83); + assert_or_panic(v[59] == 84); + assert_or_panic(v[60] == 85); + assert_or_panic(v[61] == 86); + assert_or_panic(v[62] == 87); + assert_or_panic(v[63] == 88); + zig_vector_64_u8((Vector_64_u8){ + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + }, 64); +} + +typedef uint8_t Vector_96_u8 __attribute__((vector_size(96 * sizeof(uint8_t)))); + +Vector_96_u8 zig_ret_vector_96_u8(void); +void zig_vector_96_u8(Vector_96_u8, size_t); + +Vector_96_u8 c_ret_vector_96_u8(void) { + return (Vector_96_u8){ + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + }; +} +void c_vector_96_u8(Vector_96_u8 v, size_t i) { + assert_or_panic(v[0] == 78); + assert_or_panic(v[1] == 79); + assert_or_panic(v[2] == 80); + assert_or_panic(v[3] == 81); + assert_or_panic(v[4] == 82); + assert_or_panic(v[5] == 83); + assert_or_panic(v[6] == 84); + assert_or_panic(v[7] == 85); + assert_or_panic(v[8] == 86); + assert_or_panic(v[9] == 87); + assert_or_panic(v[10] == 88); + assert_or_panic(v[11] == 89); + assert_or_panic(v[12] == 90); + assert_or_panic(v[13] == 91); + assert_or_panic(v[14] == 92); + assert_or_panic(v[15] == 93); + assert_or_panic(v[16] == 94); + assert_or_panic(v[17] == 95); + assert_or_panic(v[18] == 96); + assert_or_panic(v[19] == 97); + assert_or_panic(v[20] == 98); + assert_or_panic(v[21] == 99); + assert_or_panic(v[22] == 0); + assert_or_panic(v[23] == 1); + assert_or_panic(v[24] == 2); + assert_or_panic(v[25] == 3); + assert_or_panic(v[26] == 4); + assert_or_panic(v[27] == 5); + assert_or_panic(v[28] == 6); + assert_or_panic(v[29] == 7); + assert_or_panic(v[30] == 8); + assert_or_panic(v[31] == 9); + assert_or_panic(v[32] == 10); + assert_or_panic(v[33] == 11); + assert_or_panic(v[34] == 12); + assert_or_panic(v[35] == 13); + assert_or_panic(v[36] == 14); + assert_or_panic(v[37] == 15); + assert_or_panic(v[38] == 16); + assert_or_panic(v[39] == 17); + assert_or_panic(v[40] == 18); + assert_or_panic(v[41] == 19); + assert_or_panic(v[42] == 20); + assert_or_panic(v[43] == 21); + assert_or_panic(v[44] == 22); + assert_or_panic(v[45] == 23); + assert_or_panic(v[46] == 24); + assert_or_panic(v[47] == 25); + assert_or_panic(v[48] == 26); + assert_or_panic(v[49] == 27); + assert_or_panic(v[50] == 28); + assert_or_panic(v[51] == 29); + assert_or_panic(v[52] == 30); + assert_or_panic(v[53] == 31); + assert_or_panic(v[54] == 32); + assert_or_panic(v[55] == 33); + assert_or_panic(v[56] == 34); + assert_or_panic(v[57] == 35); + assert_or_panic(v[58] == 36); + assert_or_panic(v[59] == 37); + assert_or_panic(v[60] == 38); + assert_or_panic(v[61] == 39); + assert_or_panic(v[62] == 40); + assert_or_panic(v[63] == 41); + assert_or_panic(v[64] == 42); + assert_or_panic(v[65] == 43); + assert_or_panic(v[66] == 44); + assert_or_panic(v[67] == 45); + assert_or_panic(v[68] == 46); + assert_or_panic(v[69] == 47); + assert_or_panic(v[70] == 48); + assert_or_panic(v[71] == 49); + assert_or_panic(v[72] == 50); + assert_or_panic(v[73] == 51); + assert_or_panic(v[74] == 52); + assert_or_panic(v[75] == 53); + assert_or_panic(v[76] == 54); + assert_or_panic(v[77] == 55); + assert_or_panic(v[80] == 58); + assert_or_panic(v[81] == 59); + assert_or_panic(v[82] == 60); + assert_or_panic(v[83] == 61); + assert_or_panic(v[84] == 62); + assert_or_panic(v[85] == 63); + assert_or_panic(v[86] == 64); + assert_or_panic(v[87] == 65); + assert_or_panic(v[88] == 66); + assert_or_panic(v[89] == 67); + assert_or_panic(v[90] == 68); + assert_or_panic(v[91] == 69); + assert_or_panic(v[92] == 70); + assert_or_panic(v[93] == 71); + assert_or_panic(v[94] == 72); + assert_or_panic(v[95] == 73); + assert_or_panic(i == 96); +} +void c_test_vector_96_u8(void) { + Vector_96_u8 v = zig_ret_vector_96_u8(); + assert_or_panic(v[0] == 90); + assert_or_panic(v[1] == 91); + assert_or_panic(v[2] == 92); + assert_or_panic(v[3] == 93); + assert_or_panic(v[4] == 94); + assert_or_panic(v[5] == 95); + assert_or_panic(v[6] == 96); + assert_or_panic(v[7] == 97); + assert_or_panic(v[8] == 98); + assert_or_panic(v[9] == 99); + assert_or_panic(v[10] == 0); + assert_or_panic(v[11] == 1); + assert_or_panic(v[12] == 2); + assert_or_panic(v[13] == 3); + assert_or_panic(v[14] == 4); + assert_or_panic(v[15] == 5); + assert_or_panic(v[16] == 6); + assert_or_panic(v[17] == 7); + assert_or_panic(v[18] == 8); + assert_or_panic(v[19] == 9); + assert_or_panic(v[20] == 10); + assert_or_panic(v[21] == 11); + assert_or_panic(v[22] == 12); + assert_or_panic(v[23] == 13); + assert_or_panic(v[24] == 14); + assert_or_panic(v[25] == 15); + assert_or_panic(v[26] == 16); + assert_or_panic(v[27] == 17); + assert_or_panic(v[28] == 18); + assert_or_panic(v[29] == 19); + assert_or_panic(v[30] == 20); + assert_or_panic(v[31] == 21); + assert_or_panic(v[32] == 22); + assert_or_panic(v[33] == 23); + assert_or_panic(v[34] == 24); + assert_or_panic(v[35] == 25); + assert_or_panic(v[36] == 26); + assert_or_panic(v[37] == 27); + assert_or_panic(v[38] == 28); + assert_or_panic(v[39] == 29); + assert_or_panic(v[40] == 30); + assert_or_panic(v[41] == 31); + assert_or_panic(v[42] == 32); + assert_or_panic(v[43] == 33); + assert_or_panic(v[44] == 34); + assert_or_panic(v[45] == 35); + assert_or_panic(v[46] == 36); + assert_or_panic(v[47] == 37); + assert_or_panic(v[48] == 38); + assert_or_panic(v[49] == 39); + assert_or_panic(v[50] == 40); + assert_or_panic(v[51] == 41); + assert_or_panic(v[52] == 42); + assert_or_panic(v[53] == 43); + assert_or_panic(v[54] == 44); + assert_or_panic(v[55] == 45); + assert_or_panic(v[56] == 46); + assert_or_panic(v[57] == 47); + assert_or_panic(v[58] == 48); + assert_or_panic(v[59] == 49); + assert_or_panic(v[60] == 50); + assert_or_panic(v[61] == 51); + assert_or_panic(v[62] == 52); + assert_or_panic(v[63] == 53); + assert_or_panic(v[64] == 54); + assert_or_panic(v[65] == 55); + assert_or_panic(v[66] == 56); + assert_or_panic(v[67] == 57); + assert_or_panic(v[68] == 58); + assert_or_panic(v[69] == 59); + assert_or_panic(v[70] == 60); + assert_or_panic(v[71] == 61); + assert_or_panic(v[72] == 62); + assert_or_panic(v[73] == 63); + assert_or_panic(v[74] == 64); + assert_or_panic(v[75] == 65); + assert_or_panic(v[76] == 66); + assert_or_panic(v[77] == 67); + assert_or_panic(v[78] == 68); + assert_or_panic(v[79] == 69); + assert_or_panic(v[80] == 70); + assert_or_panic(v[81] == 71); + assert_or_panic(v[82] == 72); + assert_or_panic(v[83] == 73); + assert_or_panic(v[84] == 74); + assert_or_panic(v[85] == 75); + assert_or_panic(v[86] == 76); + assert_or_panic(v[87] == 77); + assert_or_panic(v[88] == 78); + assert_or_panic(v[89] == 79); + assert_or_panic(v[90] == 80); + assert_or_panic(v[91] == 81); + assert_or_panic(v[92] == 82); + assert_or_panic(v[93] == 83); + assert_or_panic(v[94] == 84); + assert_or_panic(v[95] == 85); + zig_vector_96_u8((Vector_96_u8){ + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + }, 96); +} + +typedef uint8_t Vector_128_u8 __attribute__((vector_size(128 * sizeof(uint8_t)))); + +Vector_128_u8 zig_ret_vector_128_u8(void); +void zig_vector_128_u8(Vector_128_u8, size_t); + +Vector_128_u8 c_ret_vector_128_u8(void) { + return (Vector_128_u8){ + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + }; +} +void c_vector_128_u8(Vector_128_u8 v, size_t i) { + assert_or_panic(v[0] == 58); + assert_or_panic(v[1] == 59); + assert_or_panic(v[2] == 60); + assert_or_panic(v[3] == 61); + assert_or_panic(v[4] == 62); + assert_or_panic(v[5] == 63); + assert_or_panic(v[6] == 64); + assert_or_panic(v[7] == 65); + assert_or_panic(v[8] == 66); + assert_or_panic(v[9] == 67); + assert_or_panic(v[10] == 68); + assert_or_panic(v[11] == 69); + assert_or_panic(v[12] == 70); + assert_or_panic(v[13] == 71); + assert_or_panic(v[14] == 72); + assert_or_panic(v[15] == 73); + assert_or_panic(v[16] == 74); + assert_or_panic(v[17] == 75); + assert_or_panic(v[18] == 76); + assert_or_panic(v[19] == 77); + assert_or_panic(v[20] == 78); + assert_or_panic(v[21] == 79); + assert_or_panic(v[22] == 80); + assert_or_panic(v[23] == 81); + assert_or_panic(v[24] == 82); + assert_or_panic(v[25] == 83); + assert_or_panic(v[26] == 84); + assert_or_panic(v[27] == 85); + assert_or_panic(v[28] == 86); + assert_or_panic(v[29] == 87); + assert_or_panic(v[30] == 88); + assert_or_panic(v[31] == 89); + assert_or_panic(v[32] == 90); + assert_or_panic(v[33] == 91); + assert_or_panic(v[34] == 92); + assert_or_panic(v[35] == 93); + assert_or_panic(v[36] == 94); + assert_or_panic(v[37] == 95); + assert_or_panic(v[38] == 96); + assert_or_panic(v[39] == 97); + assert_or_panic(v[40] == 98); + assert_or_panic(v[41] == 99); + assert_or_panic(v[42] == 0); + assert_or_panic(v[43] == 1); + assert_or_panic(v[44] == 2); + assert_or_panic(v[45] == 3); + assert_or_panic(v[46] == 4); + assert_or_panic(v[47] == 5); + assert_or_panic(v[48] == 6); + assert_or_panic(v[49] == 7); + assert_or_panic(v[50] == 8); + assert_or_panic(v[51] == 9); + assert_or_panic(v[52] == 10); + assert_or_panic(v[53] == 11); + assert_or_panic(v[54] == 12); + assert_or_panic(v[55] == 13); + assert_or_panic(v[56] == 14); + assert_or_panic(v[57] == 15); + assert_or_panic(v[58] == 16); + assert_or_panic(v[59] == 17); + assert_or_panic(v[60] == 18); + assert_or_panic(v[61] == 19); + assert_or_panic(v[62] == 20); + assert_or_panic(v[63] == 21); + assert_or_panic(v[64] == 22); + assert_or_panic(v[65] == 23); + assert_or_panic(v[66] == 24); + assert_or_panic(v[67] == 25); + assert_or_panic(v[68] == 26); + assert_or_panic(v[69] == 27); + assert_or_panic(v[70] == 28); + assert_or_panic(v[71] == 29); + assert_or_panic(v[72] == 30); + assert_or_panic(v[73] == 31); + assert_or_panic(v[74] == 32); + assert_or_panic(v[75] == 33); + assert_or_panic(v[76] == 34); + assert_or_panic(v[77] == 35); + assert_or_panic(v[78] == 36); + assert_or_panic(v[79] == 37); + assert_or_panic(v[80] == 38); + assert_or_panic(v[81] == 39); + assert_or_panic(v[82] == 40); + assert_or_panic(v[83] == 41); + assert_or_panic(v[84] == 42); + assert_or_panic(v[85] == 43); + assert_or_panic(v[86] == 44); + assert_or_panic(v[87] == 45); + assert_or_panic(v[88] == 46); + assert_or_panic(v[89] == 47); + assert_or_panic(v[90] == 48); + assert_or_panic(v[91] == 49); + assert_or_panic(v[92] == 50); + assert_or_panic(v[93] == 51); + assert_or_panic(v[94] == 52); + assert_or_panic(v[95] == 53); + assert_or_panic(v[96] == 54); + assert_or_panic(v[97] == 55); + assert_or_panic(v[98] == 56); + assert_or_panic(v[99] == 57); + assert_or_panic(v[100] == 58); + assert_or_panic(v[101] == 59); + assert_or_panic(v[102] == 60); + assert_or_panic(v[103] == 61); + assert_or_panic(v[104] == 62); + assert_or_panic(v[105] == 63); + assert_or_panic(v[106] == 64); + assert_or_panic(v[107] == 65); + assert_or_panic(v[108] == 66); + assert_or_panic(v[109] == 67); + assert_or_panic(v[110] == 68); + assert_or_panic(v[111] == 69); + assert_or_panic(v[112] == 70); + assert_or_panic(v[113] == 71); + assert_or_panic(v[114] == 72); + assert_or_panic(v[115] == 73); + assert_or_panic(v[116] == 74); + assert_or_panic(v[117] == 75); + assert_or_panic(v[118] == 76); + assert_or_panic(v[119] == 77); + assert_or_panic(v[120] == 78); + assert_or_panic(v[121] == 79); + assert_or_panic(v[122] == 80); + assert_or_panic(v[123] == 81); + assert_or_panic(v[124] == 82); + assert_or_panic(v[125] == 83); + assert_or_panic(v[126] == 84); + assert_or_panic(v[127] == 85); + assert_or_panic(i == 128); +} +void c_test_vector_128_u8(void) { + Vector_128_u8 v = zig_ret_vector_128_u8(); + assert_or_panic(v[0] == 74); + assert_or_panic(v[1] == 75); + assert_or_panic(v[2] == 76); + assert_or_panic(v[3] == 77); + assert_or_panic(v[4] == 78); + assert_or_panic(v[5] == 79); + assert_or_panic(v[6] == 80); + assert_or_panic(v[7] == 81); + assert_or_panic(v[8] == 82); + assert_or_panic(v[9] == 83); + assert_or_panic(v[10] == 84); + assert_or_panic(v[11] == 85); + assert_or_panic(v[12] == 86); + assert_or_panic(v[13] == 87); + assert_or_panic(v[14] == 88); + assert_or_panic(v[15] == 89); + assert_or_panic(v[16] == 90); + assert_or_panic(v[17] == 91); + assert_or_panic(v[18] == 92); + assert_or_panic(v[19] == 93); + assert_or_panic(v[20] == 94); + assert_or_panic(v[21] == 95); + assert_or_panic(v[22] == 96); + assert_or_panic(v[23] == 97); + assert_or_panic(v[24] == 98); + assert_or_panic(v[25] == 99); + assert_or_panic(v[26] == 0); + assert_or_panic(v[27] == 1); + assert_or_panic(v[28] == 2); + assert_or_panic(v[29] == 3); + assert_or_panic(v[30] == 4); + assert_or_panic(v[31] == 5); + assert_or_panic(v[32] == 6); + assert_or_panic(v[33] == 7); + assert_or_panic(v[34] == 8); + assert_or_panic(v[35] == 9); + assert_or_panic(v[36] == 10); + assert_or_panic(v[37] == 11); + assert_or_panic(v[38] == 12); + assert_or_panic(v[39] == 13); + assert_or_panic(v[40] == 14); + assert_or_panic(v[41] == 15); + assert_or_panic(v[42] == 16); + assert_or_panic(v[43] == 17); + assert_or_panic(v[44] == 18); + assert_or_panic(v[45] == 19); + assert_or_panic(v[46] == 20); + assert_or_panic(v[47] == 21); + assert_or_panic(v[48] == 22); + assert_or_panic(v[49] == 23); + assert_or_panic(v[50] == 24); + assert_or_panic(v[51] == 25); + assert_or_panic(v[52] == 26); + assert_or_panic(v[53] == 27); + assert_or_panic(v[54] == 28); + assert_or_panic(v[55] == 29); + assert_or_panic(v[56] == 30); + assert_or_panic(v[57] == 31); + assert_or_panic(v[58] == 32); + assert_or_panic(v[59] == 33); + assert_or_panic(v[60] == 34); + assert_or_panic(v[61] == 35); + assert_or_panic(v[62] == 36); + assert_or_panic(v[63] == 37); + assert_or_panic(v[64] == 38); + assert_or_panic(v[65] == 39); + assert_or_panic(v[66] == 40); + assert_or_panic(v[67] == 41); + assert_or_panic(v[68] == 42); + assert_or_panic(v[69] == 43); + assert_or_panic(v[70] == 44); + assert_or_panic(v[71] == 45); + assert_or_panic(v[72] == 46); + assert_or_panic(v[73] == 47); + assert_or_panic(v[74] == 48); + assert_or_panic(v[75] == 49); + assert_or_panic(v[76] == 50); + assert_or_panic(v[77] == 51); + assert_or_panic(v[78] == 52); + assert_or_panic(v[79] == 53); + assert_or_panic(v[80] == 54); + assert_or_panic(v[81] == 55); + assert_or_panic(v[82] == 56); + assert_or_panic(v[83] == 57); + assert_or_panic(v[84] == 58); + assert_or_panic(v[85] == 59); + assert_or_panic(v[86] == 60); + assert_or_panic(v[87] == 61); + assert_or_panic(v[88] == 62); + assert_or_panic(v[89] == 63); + assert_or_panic(v[90] == 64); + assert_or_panic(v[91] == 65); + assert_or_panic(v[92] == 66); + assert_or_panic(v[93] == 67); + assert_or_panic(v[94] == 68); + assert_or_panic(v[95] == 69); + assert_or_panic(v[96] == 70); + assert_or_panic(v[97] == 71); + assert_or_panic(v[98] == 72); + assert_or_panic(v[99] == 73); + assert_or_panic(v[100] == 74); + assert_or_panic(v[101] == 75); + assert_or_panic(v[102] == 76); + assert_or_panic(v[103] == 77); + assert_or_panic(v[104] == 78); + assert_or_panic(v[105] == 79); + assert_or_panic(v[106] == 80); + assert_or_panic(v[107] == 81); + assert_or_panic(v[108] == 82); + assert_or_panic(v[109] == 83); + assert_or_panic(v[110] == 84); + assert_or_panic(v[111] == 85); + assert_or_panic(v[112] == 86); + assert_or_panic(v[113] == 87); + assert_or_panic(v[114] == 88); + assert_or_panic(v[115] == 89); + assert_or_panic(v[116] == 90); + assert_or_panic(v[117] == 91); + assert_or_panic(v[118] == 92); + assert_or_panic(v[119] == 93); + assert_or_panic(v[120] == 94); + assert_or_panic(v[121] == 95); + assert_or_panic(v[122] == 96); + assert_or_panic(v[123] == 97); + assert_or_panic(v[124] == 98); + assert_or_panic(v[125] == 99); + assert_or_panic(v[126] == 0); + assert_or_panic(v[127] == 1); + zig_vector_128_u8((Vector_128_u8){ + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + }, 128); +} + +typedef uint8_t Vector_192_u8 __attribute__((vector_size(192 * sizeof(uint8_t)))); + +Vector_192_u8 zig_ret_vector_192_u8(void); +void zig_vector_192_u8(Vector_192_u8, size_t); + +Vector_192_u8 c_ret_vector_192_u8(void) { + return (Vector_192_u8){ + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + }; +} +void c_vector_192_u8(Vector_192_u8 v, size_t i) { + assert_or_panic(v[0] == 62); + assert_or_panic(v[1] == 63); + assert_or_panic(v[2] == 64); + assert_or_panic(v[3] == 65); + assert_or_panic(v[4] == 66); + assert_or_panic(v[5] == 67); + assert_or_panic(v[6] == 68); + assert_or_panic(v[7] == 69); + assert_or_panic(v[8] == 70); + assert_or_panic(v[9] == 71); + assert_or_panic(v[10] == 72); + assert_or_panic(v[11] == 73); + assert_or_panic(v[12] == 74); + assert_or_panic(v[13] == 75); + assert_or_panic(v[14] == 76); + assert_or_panic(v[15] == 77); + assert_or_panic(v[16] == 78); + assert_or_panic(v[17] == 79); + assert_or_panic(v[18] == 80); + assert_or_panic(v[19] == 81); + assert_or_panic(v[20] == 82); + assert_or_panic(v[21] == 83); + assert_or_panic(v[22] == 84); + assert_or_panic(v[23] == 85); + assert_or_panic(v[24] == 86); + assert_or_panic(v[25] == 87); + assert_or_panic(v[26] == 88); + assert_or_panic(v[27] == 89); + assert_or_panic(v[28] == 90); + assert_or_panic(v[29] == 91); + assert_or_panic(v[30] == 92); + assert_or_panic(v[31] == 93); + assert_or_panic(v[32] == 94); + assert_or_panic(v[33] == 95); + assert_or_panic(v[34] == 96); + assert_or_panic(v[35] == 97); + assert_or_panic(v[36] == 98); + assert_or_panic(v[37] == 99); + assert_or_panic(v[38] == 0); + assert_or_panic(v[39] == 1); + assert_or_panic(v[40] == 2); + assert_or_panic(v[41] == 3); + assert_or_panic(v[42] == 4); + assert_or_panic(v[43] == 5); + assert_or_panic(v[44] == 6); + assert_or_panic(v[45] == 7); + assert_or_panic(v[46] == 8); + assert_or_panic(v[47] == 9); + assert_or_panic(v[48] == 10); + assert_or_panic(v[49] == 11); + assert_or_panic(v[50] == 12); + assert_or_panic(v[51] == 13); + assert_or_panic(v[52] == 14); + assert_or_panic(v[53] == 15); + assert_or_panic(v[54] == 16); + assert_or_panic(v[55] == 17); + assert_or_panic(v[56] == 18); + assert_or_panic(v[57] == 19); + assert_or_panic(v[58] == 20); + assert_or_panic(v[59] == 21); + assert_or_panic(v[60] == 22); + assert_or_panic(v[61] == 23); + assert_or_panic(v[62] == 24); + assert_or_panic(v[63] == 25); + assert_or_panic(v[64] == 26); + assert_or_panic(v[65] == 27); + assert_or_panic(v[66] == 28); + assert_or_panic(v[67] == 29); + assert_or_panic(v[68] == 30); + assert_or_panic(v[69] == 31); + assert_or_panic(v[70] == 32); + assert_or_panic(v[71] == 33); + assert_or_panic(v[72] == 34); + assert_or_panic(v[73] == 35); + assert_or_panic(v[74] == 36); + assert_or_panic(v[75] == 37); + assert_or_panic(v[76] == 38); + assert_or_panic(v[77] == 39); + assert_or_panic(v[78] == 40); + assert_or_panic(v[79] == 41); + assert_or_panic(v[80] == 42); + assert_or_panic(v[81] == 43); + assert_or_panic(v[82] == 44); + assert_or_panic(v[83] == 45); + assert_or_panic(v[84] == 46); + assert_or_panic(v[85] == 47); + assert_or_panic(v[86] == 48); + assert_or_panic(v[87] == 49); + assert_or_panic(v[88] == 50); + assert_or_panic(v[89] == 51); + assert_or_panic(v[90] == 52); + assert_or_panic(v[91] == 53); + assert_or_panic(v[92] == 54); + assert_or_panic(v[93] == 55); + assert_or_panic(v[94] == 56); + assert_or_panic(v[95] == 57); + assert_or_panic(v[96] == 58); + assert_or_panic(v[97] == 59); + assert_or_panic(v[98] == 60); + assert_or_panic(v[99] == 61); + assert_or_panic(v[100] == 62); + assert_or_panic(v[101] == 63); + assert_or_panic(v[102] == 64); + assert_or_panic(v[103] == 65); + assert_or_panic(v[104] == 66); + assert_or_panic(v[105] == 67); + assert_or_panic(v[106] == 68); + assert_or_panic(v[107] == 69); + assert_or_panic(v[108] == 70); + assert_or_panic(v[109] == 71); + assert_or_panic(v[110] == 72); + assert_or_panic(v[111] == 73); + assert_or_panic(v[112] == 74); + assert_or_panic(v[113] == 75); + assert_or_panic(v[114] == 76); + assert_or_panic(v[115] == 77); + assert_or_panic(v[116] == 78); + assert_or_panic(v[117] == 79); + assert_or_panic(v[118] == 80); + assert_or_panic(v[119] == 81); + assert_or_panic(v[120] == 82); + assert_or_panic(v[121] == 83); + assert_or_panic(v[122] == 84); + assert_or_panic(v[123] == 85); + assert_or_panic(v[124] == 86); + assert_or_panic(v[125] == 87); + assert_or_panic(v[126] == 88); + assert_or_panic(v[127] == 89); + assert_or_panic(v[128] == 90); + assert_or_panic(v[129] == 91); + assert_or_panic(v[130] == 92); + assert_or_panic(v[131] == 93); + assert_or_panic(v[132] == 94); + assert_or_panic(v[133] == 95); + assert_or_panic(v[134] == 96); + assert_or_panic(v[135] == 97); + assert_or_panic(v[136] == 98); + assert_or_panic(v[137] == 99); + assert_or_panic(v[138] == 0); + assert_or_panic(v[139] == 1); + assert_or_panic(v[140] == 2); + assert_or_panic(v[141] == 3); + assert_or_panic(v[142] == 4); + assert_or_panic(v[143] == 5); + assert_or_panic(v[144] == 6); + assert_or_panic(v[145] == 7); + assert_or_panic(v[146] == 8); + assert_or_panic(v[147] == 9); + assert_or_panic(v[148] == 10); + assert_or_panic(v[149] == 11); + assert_or_panic(v[150] == 12); + assert_or_panic(v[151] == 13); + assert_or_panic(v[152] == 14); + assert_or_panic(v[153] == 15); + assert_or_panic(v[154] == 16); + assert_or_panic(v[155] == 17); + assert_or_panic(v[156] == 18); + assert_or_panic(v[157] == 19); + assert_or_panic(v[158] == 20); + assert_or_panic(v[159] == 21); + assert_or_panic(v[160] == 22); + assert_or_panic(v[161] == 23); + assert_or_panic(v[162] == 24); + assert_or_panic(v[163] == 25); + assert_or_panic(v[164] == 26); + assert_or_panic(v[165] == 27); + assert_or_panic(v[166] == 28); + assert_or_panic(v[167] == 29); + assert_or_panic(v[168] == 30); + assert_or_panic(v[169] == 31); + assert_or_panic(v[170] == 32); + assert_or_panic(v[171] == 33); + assert_or_panic(v[172] == 34); + assert_or_panic(v[173] == 35); + assert_or_panic(v[174] == 36); + assert_or_panic(v[175] == 37); + assert_or_panic(v[176] == 38); + assert_or_panic(v[177] == 39); + assert_or_panic(v[178] == 40); + assert_or_panic(v[179] == 41); + assert_or_panic(v[180] == 42); + assert_or_panic(v[181] == 43); + assert_or_panic(v[182] == 44); + assert_or_panic(v[183] == 45); + assert_or_panic(v[184] == 46); + assert_or_panic(v[185] == 47); + assert_or_panic(v[186] == 48); + assert_or_panic(v[187] == 49); + assert_or_panic(v[188] == 50); + assert_or_panic(v[189] == 51); + assert_or_panic(v[190] == 52); + assert_or_panic(v[191] == 53); + assert_or_panic(i == 192); +} +void c_test_vector_192_u8(void) { + Vector_192_u8 v = zig_ret_vector_192_u8(); + assert_or_panic(v[0] == 86); + assert_or_panic(v[1] == 87); + assert_or_panic(v[2] == 88); + assert_or_panic(v[3] == 89); + assert_or_panic(v[4] == 90); + assert_or_panic(v[5] == 91); + assert_or_panic(v[6] == 92); + assert_or_panic(v[7] == 93); + assert_or_panic(v[8] == 94); + assert_or_panic(v[9] == 95); + assert_or_panic(v[10] == 96); + assert_or_panic(v[11] == 97); + assert_or_panic(v[12] == 98); + assert_or_panic(v[13] == 99); + assert_or_panic(v[14] == 0); + assert_or_panic(v[15] == 1); + assert_or_panic(v[16] == 2); + assert_or_panic(v[17] == 3); + assert_or_panic(v[18] == 4); + assert_or_panic(v[19] == 5); + assert_or_panic(v[20] == 6); + assert_or_panic(v[21] == 7); + assert_or_panic(v[22] == 8); + assert_or_panic(v[23] == 9); + assert_or_panic(v[24] == 10); + assert_or_panic(v[25] == 11); + assert_or_panic(v[26] == 12); + assert_or_panic(v[27] == 13); + assert_or_panic(v[28] == 14); + assert_or_panic(v[29] == 15); + assert_or_panic(v[30] == 16); + assert_or_panic(v[31] == 17); + assert_or_panic(v[32] == 18); + assert_or_panic(v[33] == 19); + assert_or_panic(v[34] == 20); + assert_or_panic(v[35] == 21); + assert_or_panic(v[36] == 22); + assert_or_panic(v[37] == 23); + assert_or_panic(v[38] == 24); + assert_or_panic(v[39] == 25); + assert_or_panic(v[40] == 26); + assert_or_panic(v[41] == 27); + assert_or_panic(v[42] == 28); + assert_or_panic(v[43] == 29); + assert_or_panic(v[44] == 30); + assert_or_panic(v[45] == 31); + assert_or_panic(v[46] == 32); + assert_or_panic(v[47] == 33); + assert_or_panic(v[48] == 34); + assert_or_panic(v[49] == 35); + assert_or_panic(v[50] == 36); + assert_or_panic(v[51] == 37); + assert_or_panic(v[52] == 38); + assert_or_panic(v[53] == 39); + assert_or_panic(v[54] == 40); + assert_or_panic(v[55] == 41); + assert_or_panic(v[56] == 42); + assert_or_panic(v[57] == 43); + assert_or_panic(v[58] == 44); + assert_or_panic(v[59] == 45); + assert_or_panic(v[60] == 46); + assert_or_panic(v[61] == 47); + assert_or_panic(v[62] == 48); + assert_or_panic(v[63] == 49); + assert_or_panic(v[64] == 50); + assert_or_panic(v[65] == 51); + assert_or_panic(v[66] == 52); + assert_or_panic(v[67] == 53); + assert_or_panic(v[68] == 54); + assert_or_panic(v[69] == 55); + assert_or_panic(v[70] == 56); + assert_or_panic(v[71] == 57); + assert_or_panic(v[72] == 58); + assert_or_panic(v[73] == 59); + assert_or_panic(v[74] == 60); + assert_or_panic(v[75] == 61); + assert_or_panic(v[76] == 62); + assert_or_panic(v[77] == 63); + assert_or_panic(v[78] == 64); + assert_or_panic(v[79] == 65); + assert_or_panic(v[80] == 66); + assert_or_panic(v[81] == 67); + assert_or_panic(v[82] == 68); + assert_or_panic(v[83] == 69); + assert_or_panic(v[84] == 70); + assert_or_panic(v[85] == 71); + assert_or_panic(v[86] == 72); + assert_or_panic(v[87] == 73); + assert_or_panic(v[88] == 74); + assert_or_panic(v[89] == 75); + assert_or_panic(v[90] == 76); + assert_or_panic(v[91] == 77); + assert_or_panic(v[92] == 78); + assert_or_panic(v[93] == 79); + assert_or_panic(v[94] == 80); + assert_or_panic(v[95] == 81); + assert_or_panic(v[96] == 82); + assert_or_panic(v[97] == 83); + assert_or_panic(v[98] == 84); + assert_or_panic(v[99] == 85); + assert_or_panic(v[100] == 86); + assert_or_panic(v[101] == 87); + assert_or_panic(v[102] == 88); + assert_or_panic(v[103] == 89); + assert_or_panic(v[104] == 90); + assert_or_panic(v[105] == 91); + assert_or_panic(v[106] == 92); + assert_or_panic(v[107] == 93); + assert_or_panic(v[108] == 94); + assert_or_panic(v[109] == 95); + assert_or_panic(v[110] == 96); + assert_or_panic(v[111] == 97); + assert_or_panic(v[112] == 98); + assert_or_panic(v[113] == 99); + assert_or_panic(v[114] == 0); + assert_or_panic(v[115] == 1); + assert_or_panic(v[116] == 2); + assert_or_panic(v[117] == 3); + assert_or_panic(v[118] == 4); + assert_or_panic(v[119] == 5); + assert_or_panic(v[120] == 6); + assert_or_panic(v[121] == 7); + assert_or_panic(v[122] == 8); + assert_or_panic(v[123] == 9); + assert_or_panic(v[124] == 10); + assert_or_panic(v[125] == 11); + assert_or_panic(v[126] == 12); + assert_or_panic(v[127] == 13); + assert_or_panic(v[128] == 14); + assert_or_panic(v[129] == 15); + assert_or_panic(v[130] == 16); + assert_or_panic(v[131] == 17); + assert_or_panic(v[132] == 18); + assert_or_panic(v[133] == 19); + assert_or_panic(v[134] == 20); + assert_or_panic(v[135] == 21); + assert_or_panic(v[136] == 22); + assert_or_panic(v[137] == 23); + assert_or_panic(v[138] == 24); + assert_or_panic(v[139] == 25); + assert_or_panic(v[140] == 26); + assert_or_panic(v[141] == 27); + assert_or_panic(v[142] == 28); + assert_or_panic(v[143] == 29); + assert_or_panic(v[144] == 30); + assert_or_panic(v[145] == 31); + assert_or_panic(v[146] == 32); + assert_or_panic(v[147] == 33); + assert_or_panic(v[148] == 34); + assert_or_panic(v[149] == 35); + assert_or_panic(v[150] == 36); + assert_or_panic(v[151] == 37); + assert_or_panic(v[152] == 38); + assert_or_panic(v[153] == 39); + assert_or_panic(v[154] == 40); + assert_or_panic(v[155] == 41); + assert_or_panic(v[156] == 42); + assert_or_panic(v[157] == 43); + assert_or_panic(v[158] == 44); + assert_or_panic(v[159] == 45); + assert_or_panic(v[160] == 46); + assert_or_panic(v[161] == 47); + assert_or_panic(v[162] == 48); + assert_or_panic(v[163] == 49); + assert_or_panic(v[164] == 50); + assert_or_panic(v[165] == 51); + assert_or_panic(v[166] == 52); + assert_or_panic(v[167] == 53); + assert_or_panic(v[168] == 54); + assert_or_panic(v[169] == 55); + assert_or_panic(v[170] == 56); + assert_or_panic(v[171] == 57); + assert_or_panic(v[172] == 58); + assert_or_panic(v[173] == 59); + assert_or_panic(v[174] == 60); + assert_or_panic(v[175] == 61); + assert_or_panic(v[176] == 62); + assert_or_panic(v[177] == 63); + assert_or_panic(v[178] == 64); + assert_or_panic(v[179] == 65); + assert_or_panic(v[180] == 66); + assert_or_panic(v[181] == 67); + assert_or_panic(v[182] == 68); + assert_or_panic(v[183] == 69); + assert_or_panic(v[184] == 70); + assert_or_panic(v[185] == 71); + assert_or_panic(v[186] == 72); + assert_or_panic(v[187] == 73); + assert_or_panic(v[188] == 74); + assert_or_panic(v[189] == 75); + assert_or_panic(v[190] == 76); + assert_or_panic(v[191] == 77); + zig_vector_192_u8((Vector_192_u8){ + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + }, 192); +} + +typedef uint8_t Vector_256_u8 __attribute__((vector_size(256 * sizeof(uint8_t)))); + +Vector_256_u8 zig_ret_vector_256_u8(void); +void zig_vector_256_u8(Vector_256_u8, size_t); + +Vector_256_u8 c_ret_vector_256_u8(void) { + return (Vector_256_u8){ + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + }; +} +void c_vector_256_u8(Vector_256_u8 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(v[3] == 25); + assert_or_panic(v[4] == 26); + assert_or_panic(v[5] == 27); + assert_or_panic(v[6] == 28); + assert_or_panic(v[7] == 29); + assert_or_panic(v[8] == 30); + assert_or_panic(v[9] == 31); + assert_or_panic(v[10] == 32); + assert_or_panic(v[11] == 33); + assert_or_panic(v[12] == 34); + assert_or_panic(v[13] == 35); + assert_or_panic(v[14] == 36); + assert_or_panic(v[15] == 37); + assert_or_panic(v[16] == 38); + assert_or_panic(v[17] == 39); + assert_or_panic(v[18] == 40); + assert_or_panic(v[19] == 41); + assert_or_panic(v[20] == 42); + assert_or_panic(v[21] == 43); + assert_or_panic(v[22] == 44); + assert_or_panic(v[23] == 45); + assert_or_panic(v[24] == 46); + assert_or_panic(v[25] == 47); + assert_or_panic(v[26] == 48); + assert_or_panic(v[27] == 49); + assert_or_panic(v[28] == 50); + assert_or_panic(v[29] == 51); + assert_or_panic(v[30] == 52); + assert_or_panic(v[31] == 53); + assert_or_panic(v[32] == 54); + assert_or_panic(v[33] == 55); + assert_or_panic(v[34] == 56); + assert_or_panic(v[35] == 57); + assert_or_panic(v[36] == 58); + assert_or_panic(v[37] == 59); + assert_or_panic(v[38] == 60); + assert_or_panic(v[39] == 61); + assert_or_panic(v[40] == 62); + assert_or_panic(v[41] == 63); + assert_or_panic(v[42] == 64); + assert_or_panic(v[43] == 65); + assert_or_panic(v[44] == 66); + assert_or_panic(v[45] == 67); + assert_or_panic(v[46] == 68); + assert_or_panic(v[47] == 69); + assert_or_panic(v[48] == 70); + assert_or_panic(v[49] == 71); + assert_or_panic(v[50] == 72); + assert_or_panic(v[51] == 73); + assert_or_panic(v[52] == 74); + assert_or_panic(v[53] == 75); + assert_or_panic(v[54] == 76); + assert_or_panic(v[55] == 77); + assert_or_panic(v[56] == 78); + assert_or_panic(v[57] == 79); + assert_or_panic(v[58] == 80); + assert_or_panic(v[59] == 81); + assert_or_panic(v[60] == 82); + assert_or_panic(v[61] == 83); + assert_or_panic(v[62] == 84); + assert_or_panic(v[63] == 85); + assert_or_panic(v[64] == 86); + assert_or_panic(v[65] == 87); + assert_or_panic(v[66] == 88); + assert_or_panic(v[67] == 89); + assert_or_panic(v[68] == 90); + assert_or_panic(v[69] == 91); + assert_or_panic(v[70] == 92); + assert_or_panic(v[71] == 93); + assert_or_panic(v[72] == 94); + assert_or_panic(v[73] == 95); + assert_or_panic(v[74] == 96); + assert_or_panic(v[75] == 97); + assert_or_panic(v[76] == 98); + assert_or_panic(v[77] == 99); + assert_or_panic(v[78] == 0); + assert_or_panic(v[79] == 1); + assert_or_panic(v[80] == 2); + assert_or_panic(v[81] == 3); + assert_or_panic(v[82] == 4); + assert_or_panic(v[83] == 5); + assert_or_panic(v[84] == 6); + assert_or_panic(v[85] == 7); + assert_or_panic(v[86] == 8); + assert_or_panic(v[87] == 9); + assert_or_panic(v[88] == 10); + assert_or_panic(v[89] == 11); + assert_or_panic(v[90] == 12); + assert_or_panic(v[91] == 13); + assert_or_panic(v[92] == 14); + assert_or_panic(v[93] == 15); + assert_or_panic(v[94] == 16); + assert_or_panic(v[95] == 17); + assert_or_panic(v[96] == 18); + assert_or_panic(v[97] == 19); + assert_or_panic(v[98] == 20); + assert_or_panic(v[99] == 21); + assert_or_panic(v[100] == 22); + assert_or_panic(v[101] == 23); + assert_or_panic(v[102] == 24); + assert_or_panic(v[103] == 25); + assert_or_panic(v[104] == 26); + assert_or_panic(v[105] == 27); + assert_or_panic(v[106] == 28); + assert_or_panic(v[107] == 29); + assert_or_panic(v[108] == 30); + assert_or_panic(v[109] == 31); + assert_or_panic(v[110] == 32); + assert_or_panic(v[111] == 33); + assert_or_panic(v[112] == 34); + assert_or_panic(v[113] == 35); + assert_or_panic(v[114] == 36); + assert_or_panic(v[115] == 37); + assert_or_panic(v[116] == 38); + assert_or_panic(v[117] == 39); + assert_or_panic(v[118] == 40); + assert_or_panic(v[119] == 41); + assert_or_panic(v[120] == 42); + assert_or_panic(v[121] == 43); + assert_or_panic(v[122] == 44); + assert_or_panic(v[123] == 45); + assert_or_panic(v[124] == 46); + assert_or_panic(v[125] == 47); + assert_or_panic(v[126] == 48); + assert_or_panic(v[127] == 49); + assert_or_panic(v[128] == 50); + assert_or_panic(v[129] == 51); + assert_or_panic(v[130] == 52); + assert_or_panic(v[131] == 53); + assert_or_panic(v[132] == 54); + assert_or_panic(v[133] == 55); + assert_or_panic(v[134] == 56); + assert_or_panic(v[135] == 57); + assert_or_panic(v[136] == 58); + assert_or_panic(v[137] == 59); + assert_or_panic(v[138] == 60); + assert_or_panic(v[139] == 61); + assert_or_panic(v[140] == 62); + assert_or_panic(v[141] == 63); + assert_or_panic(v[142] == 64); + assert_or_panic(v[143] == 65); + assert_or_panic(v[144] == 66); + assert_or_panic(v[145] == 67); + assert_or_panic(v[146] == 68); + assert_or_panic(v[147] == 69); + assert_or_panic(v[148] == 70); + assert_or_panic(v[149] == 71); + assert_or_panic(v[150] == 72); + assert_or_panic(v[151] == 73); + assert_or_panic(v[152] == 74); + assert_or_panic(v[153] == 75); + assert_or_panic(v[154] == 76); + assert_or_panic(v[155] == 77); + assert_or_panic(v[156] == 78); + assert_or_panic(v[157] == 79); + assert_or_panic(v[158] == 80); + assert_or_panic(v[159] == 81); + assert_or_panic(v[160] == 82); + assert_or_panic(v[161] == 83); + assert_or_panic(v[162] == 84); + assert_or_panic(v[163] == 85); + assert_or_panic(v[164] == 86); + assert_or_panic(v[165] == 87); + assert_or_panic(v[166] == 88); + assert_or_panic(v[167] == 89); + assert_or_panic(v[168] == 90); + assert_or_panic(v[169] == 91); + assert_or_panic(v[170] == 92); + assert_or_panic(v[171] == 93); + assert_or_panic(v[172] == 94); + assert_or_panic(v[173] == 95); + assert_or_panic(v[174] == 96); + assert_or_panic(v[175] == 97); + assert_or_panic(v[176] == 98); + assert_or_panic(v[177] == 99); + assert_or_panic(v[178] == 0); + assert_or_panic(v[179] == 1); + assert_or_panic(v[180] == 2); + assert_or_panic(v[181] == 3); + assert_or_panic(v[182] == 4); + assert_or_panic(v[183] == 5); + assert_or_panic(v[184] == 6); + assert_or_panic(v[185] == 7); + assert_or_panic(v[186] == 8); + assert_or_panic(v[187] == 9); + assert_or_panic(v[188] == 10); + assert_or_panic(v[189] == 11); + assert_or_panic(v[190] == 12); + assert_or_panic(v[191] == 13); + assert_or_panic(v[192] == 14); + assert_or_panic(v[193] == 15); + assert_or_panic(v[194] == 16); + assert_or_panic(v[195] == 17); + assert_or_panic(v[196] == 18); + assert_or_panic(v[197] == 19); + assert_or_panic(v[198] == 20); + assert_or_panic(v[199] == 21); + assert_or_panic(v[200] == 22); + assert_or_panic(v[201] == 23); + assert_or_panic(v[202] == 24); + assert_or_panic(v[203] == 25); + assert_or_panic(v[204] == 26); + assert_or_panic(v[205] == 27); + assert_or_panic(v[206] == 28); + assert_or_panic(v[207] == 29); + assert_or_panic(v[208] == 30); + assert_or_panic(v[209] == 31); + assert_or_panic(v[210] == 32); + assert_or_panic(v[211] == 33); + assert_or_panic(v[212] == 34); + assert_or_panic(v[213] == 35); + assert_or_panic(v[214] == 36); + assert_or_panic(v[215] == 37); + assert_or_panic(v[216] == 38); + assert_or_panic(v[217] == 39); + assert_or_panic(v[218] == 40); + assert_or_panic(v[219] == 41); + assert_or_panic(v[220] == 42); + assert_or_panic(v[221] == 43); + assert_or_panic(v[222] == 44); + assert_or_panic(v[223] == 45); + assert_or_panic(v[224] == 46); + assert_or_panic(v[225] == 47); + assert_or_panic(v[226] == 48); + assert_or_panic(v[227] == 49); + assert_or_panic(v[228] == 50); + assert_or_panic(v[229] == 51); + assert_or_panic(v[230] == 52); + assert_or_panic(v[231] == 53); + assert_or_panic(v[232] == 54); + assert_or_panic(v[233] == 55); + assert_or_panic(v[234] == 56); + assert_or_panic(v[235] == 57); + assert_or_panic(v[236] == 58); + assert_or_panic(v[237] == 59); + assert_or_panic(v[238] == 60); + assert_or_panic(v[239] == 61); + assert_or_panic(v[240] == 62); + assert_or_panic(v[241] == 63); + assert_or_panic(v[242] == 64); + assert_or_panic(v[243] == 65); + assert_or_panic(v[244] == 66); + assert_or_panic(v[245] == 67); + assert_or_panic(v[246] == 68); + assert_or_panic(v[247] == 69); + assert_or_panic(v[248] == 70); + assert_or_panic(v[249] == 71); + assert_or_panic(v[250] == 72); + assert_or_panic(v[251] == 73); + assert_or_panic(v[252] == 74); + assert_or_panic(v[253] == 75); + assert_or_panic(v[254] == 76); + assert_or_panic(v[255] == 77); + assert_or_panic(i == 256); +} +void c_test_vector_256_u8(void) { + Vector_256_u8 v = zig_ret_vector_256_u8(); + assert_or_panic(v[0] == 54); + assert_or_panic(v[1] == 55); + assert_or_panic(v[2] == 56); + assert_or_panic(v[3] == 57); + assert_or_panic(v[4] == 58); + assert_or_panic(v[5] == 59); + assert_or_panic(v[6] == 60); + assert_or_panic(v[7] == 61); + assert_or_panic(v[8] == 62); + assert_or_panic(v[9] == 63); + assert_or_panic(v[10] == 64); + assert_or_panic(v[11] == 65); + assert_or_panic(v[12] == 66); + assert_or_panic(v[13] == 67); + assert_or_panic(v[14] == 68); + assert_or_panic(v[15] == 69); + assert_or_panic(v[16] == 70); + assert_or_panic(v[17] == 71); + assert_or_panic(v[18] == 72); + assert_or_panic(v[19] == 73); + assert_or_panic(v[20] == 74); + assert_or_panic(v[21] == 75); + assert_or_panic(v[22] == 76); + assert_or_panic(v[23] == 77); + assert_or_panic(v[24] == 78); + assert_or_panic(v[25] == 79); + assert_or_panic(v[26] == 80); + assert_or_panic(v[27] == 81); + assert_or_panic(v[28] == 82); + assert_or_panic(v[29] == 83); + assert_or_panic(v[30] == 84); + assert_or_panic(v[31] == 85); + assert_or_panic(v[32] == 86); + assert_or_panic(v[33] == 87); + assert_or_panic(v[34] == 88); + assert_or_panic(v[35] == 89); + assert_or_panic(v[36] == 90); + assert_or_panic(v[37] == 91); + assert_or_panic(v[38] == 92); + assert_or_panic(v[39] == 93); + assert_or_panic(v[40] == 94); + assert_or_panic(v[41] == 95); + assert_or_panic(v[42] == 96); + assert_or_panic(v[43] == 97); + assert_or_panic(v[44] == 98); + assert_or_panic(v[45] == 99); + assert_or_panic(v[46] == 0); + assert_or_panic(v[47] == 1); + assert_or_panic(v[48] == 2); + assert_or_panic(v[49] == 3); + assert_or_panic(v[50] == 4); + assert_or_panic(v[51] == 5); + assert_or_panic(v[52] == 6); + assert_or_panic(v[53] == 7); + assert_or_panic(v[54] == 8); + assert_or_panic(v[55] == 9); + assert_or_panic(v[56] == 10); + assert_or_panic(v[57] == 11); + assert_or_panic(v[58] == 12); + assert_or_panic(v[59] == 13); + assert_or_panic(v[60] == 14); + assert_or_panic(v[61] == 15); + assert_or_panic(v[62] == 16); + assert_or_panic(v[63] == 17); + assert_or_panic(v[64] == 18); + assert_or_panic(v[65] == 19); + assert_or_panic(v[66] == 20); + assert_or_panic(v[67] == 21); + assert_or_panic(v[68] == 22); + assert_or_panic(v[69] == 23); + assert_or_panic(v[70] == 24); + assert_or_panic(v[71] == 25); + assert_or_panic(v[72] == 26); + assert_or_panic(v[73] == 27); + assert_or_panic(v[74] == 28); + assert_or_panic(v[75] == 29); + assert_or_panic(v[76] == 30); + assert_or_panic(v[77] == 31); + assert_or_panic(v[78] == 32); + assert_or_panic(v[79] == 33); + assert_or_panic(v[80] == 34); + assert_or_panic(v[81] == 35); + assert_or_panic(v[82] == 36); + assert_or_panic(v[83] == 37); + assert_or_panic(v[84] == 38); + assert_or_panic(v[85] == 39); + assert_or_panic(v[86] == 40); + assert_or_panic(v[87] == 41); + assert_or_panic(v[88] == 42); + assert_or_panic(v[89] == 43); + assert_or_panic(v[90] == 44); + assert_or_panic(v[91] == 45); + assert_or_panic(v[92] == 46); + assert_or_panic(v[93] == 47); + assert_or_panic(v[94] == 48); + assert_or_panic(v[95] == 49); + assert_or_panic(v[96] == 50); + assert_or_panic(v[97] == 51); + assert_or_panic(v[98] == 52); + assert_or_panic(v[99] == 53); + assert_or_panic(v[100] == 54); + assert_or_panic(v[101] == 55); + assert_or_panic(v[102] == 56); + assert_or_panic(v[103] == 57); + assert_or_panic(v[104] == 58); + assert_or_panic(v[105] == 59); + assert_or_panic(v[106] == 60); + assert_or_panic(v[107] == 61); + assert_or_panic(v[108] == 62); + assert_or_panic(v[109] == 63); + assert_or_panic(v[110] == 64); + assert_or_panic(v[111] == 65); + assert_or_panic(v[112] == 66); + assert_or_panic(v[113] == 67); + assert_or_panic(v[114] == 68); + assert_or_panic(v[115] == 69); + assert_or_panic(v[116] == 70); + assert_or_panic(v[117] == 71); + assert_or_panic(v[118] == 72); + assert_or_panic(v[119] == 73); + assert_or_panic(v[120] == 74); + assert_or_panic(v[121] == 75); + assert_or_panic(v[122] == 76); + assert_or_panic(v[123] == 77); + assert_or_panic(v[124] == 78); + assert_or_panic(v[125] == 79); + assert_or_panic(v[126] == 80); + assert_or_panic(v[127] == 81); + assert_or_panic(v[128] == 82); + assert_or_panic(v[129] == 83); + assert_or_panic(v[130] == 84); + assert_or_panic(v[131] == 85); + assert_or_panic(v[132] == 86); + assert_or_panic(v[133] == 87); + assert_or_panic(v[134] == 88); + assert_or_panic(v[135] == 89); + assert_or_panic(v[136] == 90); + assert_or_panic(v[137] == 91); + assert_or_panic(v[138] == 92); + assert_or_panic(v[139] == 93); + assert_or_panic(v[140] == 94); + assert_or_panic(v[141] == 95); + assert_or_panic(v[142] == 96); + assert_or_panic(v[143] == 97); + assert_or_panic(v[144] == 98); + assert_or_panic(v[145] == 99); + assert_or_panic(v[146] == 0); + assert_or_panic(v[147] == 1); + assert_or_panic(v[148] == 2); + assert_or_panic(v[149] == 3); + assert_or_panic(v[150] == 4); + assert_or_panic(v[151] == 5); + assert_or_panic(v[152] == 6); + assert_or_panic(v[153] == 7); + assert_or_panic(v[154] == 8); + assert_or_panic(v[155] == 9); + assert_or_panic(v[156] == 10); + assert_or_panic(v[157] == 11); + assert_or_panic(v[158] == 12); + assert_or_panic(v[159] == 13); + assert_or_panic(v[160] == 14); + assert_or_panic(v[161] == 15); + assert_or_panic(v[162] == 16); + assert_or_panic(v[163] == 17); + assert_or_panic(v[164] == 18); + assert_or_panic(v[165] == 19); + assert_or_panic(v[166] == 20); + assert_or_panic(v[167] == 21); + assert_or_panic(v[168] == 22); + assert_or_panic(v[169] == 23); + assert_or_panic(v[170] == 24); + assert_or_panic(v[171] == 25); + assert_or_panic(v[172] == 26); + assert_or_panic(v[173] == 27); + assert_or_panic(v[174] == 28); + assert_or_panic(v[175] == 29); + assert_or_panic(v[176] == 30); + assert_or_panic(v[177] == 31); + assert_or_panic(v[178] == 32); + assert_or_panic(v[179] == 33); + assert_or_panic(v[180] == 34); + assert_or_panic(v[181] == 35); + assert_or_panic(v[182] == 36); + assert_or_panic(v[183] == 37); + assert_or_panic(v[184] == 38); + assert_or_panic(v[185] == 39); + assert_or_panic(v[186] == 40); + assert_or_panic(v[187] == 41); + assert_or_panic(v[188] == 42); + assert_or_panic(v[189] == 43); + assert_or_panic(v[190] == 44); + assert_or_panic(v[191] == 45); + assert_or_panic(v[192] == 46); + assert_or_panic(v[193] == 47); + assert_or_panic(v[194] == 48); + assert_or_panic(v[195] == 49); + assert_or_panic(v[196] == 50); + assert_or_panic(v[197] == 51); + assert_or_panic(v[198] == 52); + assert_or_panic(v[199] == 53); + assert_or_panic(v[200] == 54); + assert_or_panic(v[201] == 55); + assert_or_panic(v[202] == 56); + assert_or_panic(v[203] == 57); + assert_or_panic(v[204] == 58); + assert_or_panic(v[205] == 59); + assert_or_panic(v[206] == 60); + assert_or_panic(v[207] == 61); + assert_or_panic(v[208] == 62); + assert_or_panic(v[209] == 63); + assert_or_panic(v[210] == 64); + assert_or_panic(v[211] == 65); + assert_or_panic(v[212] == 66); + assert_or_panic(v[213] == 67); + assert_or_panic(v[214] == 68); + assert_or_panic(v[215] == 69); + assert_or_panic(v[216] == 70); + assert_or_panic(v[217] == 71); + assert_or_panic(v[218] == 72); + assert_or_panic(v[219] == 73); + assert_or_panic(v[220] == 74); + assert_or_panic(v[221] == 75); + assert_or_panic(v[222] == 76); + assert_or_panic(v[223] == 77); + assert_or_panic(v[224] == 78); + assert_or_panic(v[225] == 79); + assert_or_panic(v[226] == 80); + assert_or_panic(v[227] == 81); + assert_or_panic(v[228] == 82); + assert_or_panic(v[229] == 83); + assert_or_panic(v[230] == 84); + assert_or_panic(v[231] == 85); + assert_or_panic(v[232] == 86); + assert_or_panic(v[233] == 87); + assert_or_panic(v[234] == 88); + assert_or_panic(v[235] == 89); + assert_or_panic(v[236] == 90); + assert_or_panic(v[237] == 91); + assert_or_panic(v[238] == 92); + assert_or_panic(v[239] == 93); + assert_or_panic(v[240] == 94); + assert_or_panic(v[241] == 95); + assert_or_panic(v[242] == 96); + assert_or_panic(v[243] == 97); + assert_or_panic(v[244] == 98); + assert_or_panic(v[245] == 99); + assert_or_panic(v[246] == 0); + assert_or_panic(v[247] == 1); + assert_or_panic(v[248] == 2); + assert_or_panic(v[249] == 3); + assert_or_panic(v[250] == 4); + assert_or_panic(v[251] == 5); + assert_or_panic(v[252] == 6); + assert_or_panic(v[253] == 7); + assert_or_panic(v[254] == 8); + assert_or_panic(v[255] == 9); + zig_vector_256_u8((Vector_256_u8){ + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + }, 256); +} + +typedef uint8_t Vector_384_u8 __attribute__((vector_size(384 * sizeof(uint8_t)))); + +Vector_384_u8 zig_ret_vector_384_u8(void); +void zig_vector_384_u8(Vector_384_u8, size_t); + +Vector_384_u8 c_ret_vector_384_u8(void) { + return (Vector_384_u8){ + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + }; +} +void c_vector_384_u8(Vector_384_u8 v, size_t i) { + assert_or_panic(v[0] == 30); + assert_or_panic(v[1] == 31); + assert_or_panic(v[2] == 32); + assert_or_panic(v[3] == 33); + assert_or_panic(v[4] == 34); + assert_or_panic(v[5] == 35); + assert_or_panic(v[6] == 36); + assert_or_panic(v[7] == 37); + assert_or_panic(v[8] == 38); + assert_or_panic(v[9] == 39); + assert_or_panic(v[10] == 40); + assert_or_panic(v[11] == 41); + assert_or_panic(v[12] == 42); + assert_or_panic(v[13] == 43); + assert_or_panic(v[14] == 44); + assert_or_panic(v[15] == 45); + assert_or_panic(v[16] == 46); + assert_or_panic(v[17] == 47); + assert_or_panic(v[18] == 48); + assert_or_panic(v[19] == 49); + assert_or_panic(v[20] == 50); + assert_or_panic(v[21] == 51); + assert_or_panic(v[22] == 52); + assert_or_panic(v[23] == 53); + assert_or_panic(v[24] == 54); + assert_or_panic(v[25] == 55); + assert_or_panic(v[26] == 56); + assert_or_panic(v[27] == 57); + assert_or_panic(v[28] == 58); + assert_or_panic(v[29] == 59); + assert_or_panic(v[30] == 60); + assert_or_panic(v[31] == 61); + assert_or_panic(v[32] == 62); + assert_or_panic(v[33] == 63); + assert_or_panic(v[34] == 64); + assert_or_panic(v[35] == 65); + assert_or_panic(v[36] == 66); + assert_or_panic(v[37] == 67); + assert_or_panic(v[38] == 68); + assert_or_panic(v[39] == 69); + assert_or_panic(v[40] == 70); + assert_or_panic(v[41] == 71); + assert_or_panic(v[42] == 72); + assert_or_panic(v[43] == 73); + assert_or_panic(v[44] == 74); + assert_or_panic(v[45] == 75); + assert_or_panic(v[46] == 76); + assert_or_panic(v[47] == 77); + assert_or_panic(v[48] == 78); + assert_or_panic(v[49] == 79); + assert_or_panic(v[50] == 80); + assert_or_panic(v[51] == 81); + assert_or_panic(v[52] == 82); + assert_or_panic(v[53] == 83); + assert_or_panic(v[54] == 84); + assert_or_panic(v[55] == 85); + assert_or_panic(v[56] == 86); + assert_or_panic(v[57] == 87); + assert_or_panic(v[58] == 88); + assert_or_panic(v[59] == 89); + assert_or_panic(v[60] == 90); + assert_or_panic(v[61] == 91); + assert_or_panic(v[62] == 92); + assert_or_panic(v[63] == 93); + assert_or_panic(v[64] == 94); + assert_or_panic(v[65] == 95); + assert_or_panic(v[66] == 96); + assert_or_panic(v[67] == 97); + assert_or_panic(v[68] == 98); + assert_or_panic(v[69] == 99); + assert_or_panic(v[70] == 0); + assert_or_panic(v[71] == 1); + assert_or_panic(v[72] == 2); + assert_or_panic(v[73] == 3); + assert_or_panic(v[74] == 4); + assert_or_panic(v[75] == 5); + assert_or_panic(v[76] == 6); + assert_or_panic(v[77] == 7); + assert_or_panic(v[78] == 8); + assert_or_panic(v[79] == 9); + assert_or_panic(v[80] == 10); + assert_or_panic(v[81] == 11); + assert_or_panic(v[82] == 12); + assert_or_panic(v[83] == 13); + assert_or_panic(v[84] == 14); + assert_or_panic(v[85] == 15); + assert_or_panic(v[86] == 16); + assert_or_panic(v[87] == 17); + assert_or_panic(v[88] == 18); + assert_or_panic(v[89] == 19); + assert_or_panic(v[90] == 20); + assert_or_panic(v[91] == 21); + assert_or_panic(v[92] == 22); + assert_or_panic(v[93] == 23); + assert_or_panic(v[94] == 24); + assert_or_panic(v[95] == 25); + assert_or_panic(v[96] == 26); + assert_or_panic(v[97] == 27); + assert_or_panic(v[98] == 28); + assert_or_panic(v[99] == 29); + assert_or_panic(v[100] == 30); + assert_or_panic(v[101] == 31); + assert_or_panic(v[102] == 32); + assert_or_panic(v[103] == 33); + assert_or_panic(v[104] == 34); + assert_or_panic(v[105] == 35); + assert_or_panic(v[106] == 36); + assert_or_panic(v[107] == 37); + assert_or_panic(v[108] == 38); + assert_or_panic(v[109] == 39); + assert_or_panic(v[110] == 40); + assert_or_panic(v[111] == 41); + assert_or_panic(v[112] == 42); + assert_or_panic(v[113] == 43); + assert_or_panic(v[114] == 44); + assert_or_panic(v[115] == 45); + assert_or_panic(v[116] == 46); + assert_or_panic(v[117] == 47); + assert_or_panic(v[118] == 48); + assert_or_panic(v[119] == 49); + assert_or_panic(v[120] == 50); + assert_or_panic(v[121] == 51); + assert_or_panic(v[122] == 52); + assert_or_panic(v[123] == 53); + assert_or_panic(v[124] == 54); + assert_or_panic(v[125] == 55); + assert_or_panic(v[126] == 56); + assert_or_panic(v[127] == 57); + assert_or_panic(v[128] == 58); + assert_or_panic(v[129] == 59); + assert_or_panic(v[130] == 60); + assert_or_panic(v[131] == 61); + assert_or_panic(v[132] == 62); + assert_or_panic(v[133] == 63); + assert_or_panic(v[134] == 64); + assert_or_panic(v[135] == 65); + assert_or_panic(v[136] == 66); + assert_or_panic(v[137] == 67); + assert_or_panic(v[138] == 68); + assert_or_panic(v[139] == 69); + assert_or_panic(v[140] == 70); + assert_or_panic(v[141] == 71); + assert_or_panic(v[142] == 72); + assert_or_panic(v[143] == 73); + assert_or_panic(v[144] == 74); + assert_or_panic(v[145] == 75); + assert_or_panic(v[146] == 76); + assert_or_panic(v[147] == 77); + assert_or_panic(v[148] == 78); + assert_or_panic(v[149] == 79); + assert_or_panic(v[150] == 80); + assert_or_panic(v[151] == 81); + assert_or_panic(v[152] == 82); + assert_or_panic(v[153] == 83); + assert_or_panic(v[154] == 84); + assert_or_panic(v[155] == 85); + assert_or_panic(v[156] == 86); + assert_or_panic(v[157] == 87); + assert_or_panic(v[158] == 88); + assert_or_panic(v[159] == 89); + assert_or_panic(v[160] == 90); + assert_or_panic(v[161] == 91); + assert_or_panic(v[162] == 92); + assert_or_panic(v[163] == 93); + assert_or_panic(v[164] == 94); + assert_or_panic(v[165] == 95); + assert_or_panic(v[166] == 96); + assert_or_panic(v[167] == 97); + assert_or_panic(v[168] == 98); + assert_or_panic(v[169] == 99); + assert_or_panic(v[170] == 0); + assert_or_panic(v[171] == 1); + assert_or_panic(v[172] == 2); + assert_or_panic(v[173] == 3); + assert_or_panic(v[174] == 4); + assert_or_panic(v[175] == 5); + assert_or_panic(v[176] == 6); + assert_or_panic(v[177] == 7); + assert_or_panic(v[178] == 8); + assert_or_panic(v[179] == 9); + assert_or_panic(v[180] == 10); + assert_or_panic(v[181] == 11); + assert_or_panic(v[182] == 12); + assert_or_panic(v[183] == 13); + assert_or_panic(v[184] == 14); + assert_or_panic(v[185] == 15); + assert_or_panic(v[186] == 16); + assert_or_panic(v[187] == 17); + assert_or_panic(v[188] == 18); + assert_or_panic(v[189] == 19); + assert_or_panic(v[190] == 20); + assert_or_panic(v[191] == 21); + assert_or_panic(v[192] == 22); + assert_or_panic(v[193] == 23); + assert_or_panic(v[194] == 24); + assert_or_panic(v[195] == 25); + assert_or_panic(v[196] == 26); + assert_or_panic(v[197] == 27); + assert_or_panic(v[198] == 28); + assert_or_panic(v[199] == 29); + assert_or_panic(v[200] == 30); + assert_or_panic(v[201] == 31); + assert_or_panic(v[202] == 32); + assert_or_panic(v[203] == 33); + assert_or_panic(v[204] == 34); + assert_or_panic(v[205] == 35); + assert_or_panic(v[206] == 36); + assert_or_panic(v[207] == 37); + assert_or_panic(v[208] == 38); + assert_or_panic(v[209] == 39); + assert_or_panic(v[210] == 40); + assert_or_panic(v[211] == 41); + assert_or_panic(v[212] == 42); + assert_or_panic(v[213] == 43); + assert_or_panic(v[214] == 44); + assert_or_panic(v[215] == 45); + assert_or_panic(v[216] == 46); + assert_or_panic(v[217] == 47); + assert_or_panic(v[218] == 48); + assert_or_panic(v[219] == 49); + assert_or_panic(v[220] == 50); + assert_or_panic(v[221] == 51); + assert_or_panic(v[222] == 52); + assert_or_panic(v[223] == 53); + assert_or_panic(v[224] == 54); + assert_or_panic(v[225] == 55); + assert_or_panic(v[226] == 56); + assert_or_panic(v[227] == 57); + assert_or_panic(v[228] == 58); + assert_or_panic(v[229] == 59); + assert_or_panic(v[230] == 60); + assert_or_panic(v[231] == 61); + assert_or_panic(v[232] == 62); + assert_or_panic(v[233] == 63); + assert_or_panic(v[234] == 64); + assert_or_panic(v[235] == 65); + assert_or_panic(v[236] == 66); + assert_or_panic(v[237] == 67); + assert_or_panic(v[238] == 68); + assert_or_panic(v[239] == 69); + assert_or_panic(v[240] == 70); + assert_or_panic(v[241] == 71); + assert_or_panic(v[242] == 72); + assert_or_panic(v[243] == 73); + assert_or_panic(v[244] == 74); + assert_or_panic(v[245] == 75); + assert_or_panic(v[246] == 76); + assert_or_panic(v[247] == 77); + assert_or_panic(v[248] == 78); + assert_or_panic(v[249] == 79); + assert_or_panic(v[250] == 80); + assert_or_panic(v[251] == 81); + assert_or_panic(v[252] == 82); + assert_or_panic(v[253] == 83); + assert_or_panic(v[254] == 84); + assert_or_panic(v[255] == 85); + assert_or_panic(v[256] == 86); + assert_or_panic(v[257] == 87); + assert_or_panic(v[258] == 88); + assert_or_panic(v[259] == 89); + assert_or_panic(v[260] == 90); + assert_or_panic(v[261] == 91); + assert_or_panic(v[262] == 92); + assert_or_panic(v[263] == 93); + assert_or_panic(v[264] == 94); + assert_or_panic(v[265] == 95); + assert_or_panic(v[266] == 96); + assert_or_panic(v[267] == 97); + assert_or_panic(v[268] == 98); + assert_or_panic(v[269] == 99); + assert_or_panic(v[270] == 0); + assert_or_panic(v[271] == 1); + assert_or_panic(v[272] == 2); + assert_or_panic(v[273] == 3); + assert_or_panic(v[274] == 4); + assert_or_panic(v[275] == 5); + assert_or_panic(v[276] == 6); + assert_or_panic(v[277] == 7); + assert_or_panic(v[278] == 8); + assert_or_panic(v[279] == 9); + assert_or_panic(v[280] == 10); + assert_or_panic(v[281] == 11); + assert_or_panic(v[282] == 12); + assert_or_panic(v[283] == 13); + assert_or_panic(v[284] == 14); + assert_or_panic(v[285] == 15); + assert_or_panic(v[286] == 16); + assert_or_panic(v[287] == 17); + assert_or_panic(v[288] == 18); + assert_or_panic(v[289] == 19); + assert_or_panic(v[290] == 20); + assert_or_panic(v[291] == 21); + assert_or_panic(v[292] == 22); + assert_or_panic(v[293] == 23); + assert_or_panic(v[294] == 24); + assert_or_panic(v[295] == 25); + assert_or_panic(v[296] == 26); + assert_or_panic(v[297] == 27); + assert_or_panic(v[298] == 28); + assert_or_panic(v[299] == 29); + assert_or_panic(v[300] == 30); + assert_or_panic(v[301] == 31); + assert_or_panic(v[302] == 32); + assert_or_panic(v[303] == 33); + assert_or_panic(v[304] == 34); + assert_or_panic(v[305] == 35); + assert_or_panic(v[306] == 36); + assert_or_panic(v[307] == 37); + assert_or_panic(v[308] == 38); + assert_or_panic(v[309] == 39); + assert_or_panic(v[310] == 40); + assert_or_panic(v[311] == 41); + assert_or_panic(v[312] == 42); + assert_or_panic(v[313] == 43); + assert_or_panic(v[314] == 44); + assert_or_panic(v[315] == 45); + assert_or_panic(v[316] == 46); + assert_or_panic(v[317] == 47); + assert_or_panic(v[318] == 48); + assert_or_panic(v[319] == 49); + assert_or_panic(v[320] == 50); + assert_or_panic(v[321] == 51); + assert_or_panic(v[322] == 52); + assert_or_panic(v[323] == 53); + assert_or_panic(v[324] == 54); + assert_or_panic(v[325] == 55); + assert_or_panic(v[326] == 56); + assert_or_panic(v[327] == 57); + assert_or_panic(v[328] == 58); + assert_or_panic(v[329] == 59); + assert_or_panic(v[330] == 60); + assert_or_panic(v[331] == 61); + assert_or_panic(v[332] == 62); + assert_or_panic(v[333] == 63); + assert_or_panic(v[334] == 64); + assert_or_panic(v[335] == 65); + assert_or_panic(v[336] == 66); + assert_or_panic(v[337] == 67); + assert_or_panic(v[338] == 68); + assert_or_panic(v[339] == 69); + assert_or_panic(v[340] == 70); + assert_or_panic(v[341] == 71); + assert_or_panic(v[342] == 72); + assert_or_panic(v[343] == 73); + assert_or_panic(v[344] == 74); + assert_or_panic(v[345] == 75); + assert_or_panic(v[346] == 76); + assert_or_panic(v[347] == 77); + assert_or_panic(v[348] == 78); + assert_or_panic(v[349] == 79); + assert_or_panic(v[350] == 80); + assert_or_panic(v[351] == 81); + assert_or_panic(v[352] == 82); + assert_or_panic(v[353] == 83); + assert_or_panic(v[354] == 84); + assert_or_panic(v[355] == 85); + assert_or_panic(v[356] == 86); + assert_or_panic(v[357] == 87); + assert_or_panic(v[358] == 88); + assert_or_panic(v[359] == 89); + assert_or_panic(v[360] == 90); + assert_or_panic(v[361] == 91); + assert_or_panic(v[362] == 92); + assert_or_panic(v[363] == 93); + assert_or_panic(v[364] == 94); + assert_or_panic(v[365] == 95); + assert_or_panic(v[366] == 96); + assert_or_panic(v[367] == 97); + assert_or_panic(v[368] == 98); + assert_or_panic(v[369] == 99); + assert_or_panic(v[370] == 0); + assert_or_panic(v[371] == 1); + assert_or_panic(v[372] == 2); + assert_or_panic(v[373] == 3); + assert_or_panic(v[374] == 4); + assert_or_panic(v[375] == 5); + assert_or_panic(v[376] == 6); + assert_or_panic(v[377] == 7); + assert_or_panic(v[378] == 8); + assert_or_panic(v[379] == 9); + assert_or_panic(v[380] == 10); + assert_or_panic(v[381] == 11); + assert_or_panic(v[382] == 12); + assert_or_panic(v[383] == 13); + assert_or_panic(i == 384); +} +void c_test_vector_384_u8(void) { + Vector_384_u8 v = zig_ret_vector_384_u8(); + assert_or_panic(v[0] == 78); + assert_or_panic(v[1] == 79); + assert_or_panic(v[2] == 80); + assert_or_panic(v[3] == 81); + assert_or_panic(v[4] == 82); + assert_or_panic(v[5] == 83); + assert_or_panic(v[6] == 84); + assert_or_panic(v[7] == 85); + assert_or_panic(v[8] == 86); + assert_or_panic(v[9] == 87); + assert_or_panic(v[10] == 88); + assert_or_panic(v[11] == 89); + assert_or_panic(v[12] == 90); + assert_or_panic(v[13] == 91); + assert_or_panic(v[14] == 92); + assert_or_panic(v[15] == 93); + assert_or_panic(v[16] == 94); + assert_or_panic(v[17] == 95); + assert_or_panic(v[18] == 96); + assert_or_panic(v[19] == 97); + assert_or_panic(v[20] == 98); + assert_or_panic(v[21] == 99); + assert_or_panic(v[22] == 0); + assert_or_panic(v[23] == 1); + assert_or_panic(v[24] == 2); + assert_or_panic(v[25] == 3); + assert_or_panic(v[26] == 4); + assert_or_panic(v[27] == 5); + assert_or_panic(v[28] == 6); + assert_or_panic(v[29] == 7); + assert_or_panic(v[30] == 8); + assert_or_panic(v[31] == 9); + assert_or_panic(v[32] == 10); + assert_or_panic(v[33] == 11); + assert_or_panic(v[34] == 12); + assert_or_panic(v[35] == 13); + assert_or_panic(v[36] == 14); + assert_or_panic(v[37] == 15); + assert_or_panic(v[38] == 16); + assert_or_panic(v[39] == 17); + assert_or_panic(v[40] == 18); + assert_or_panic(v[41] == 19); + assert_or_panic(v[42] == 20); + assert_or_panic(v[43] == 21); + assert_or_panic(v[44] == 22); + assert_or_panic(v[45] == 23); + assert_or_panic(v[46] == 24); + assert_or_panic(v[47] == 25); + assert_or_panic(v[48] == 26); + assert_or_panic(v[49] == 27); + assert_or_panic(v[50] == 28); + assert_or_panic(v[51] == 29); + assert_or_panic(v[52] == 30); + assert_or_panic(v[53] == 31); + assert_or_panic(v[54] == 32); + assert_or_panic(v[55] == 33); + assert_or_panic(v[56] == 34); + assert_or_panic(v[57] == 35); + assert_or_panic(v[58] == 36); + assert_or_panic(v[59] == 37); + assert_or_panic(v[60] == 38); + assert_or_panic(v[61] == 39); + assert_or_panic(v[62] == 40); + assert_or_panic(v[63] == 41); + assert_or_panic(v[64] == 42); + assert_or_panic(v[65] == 43); + assert_or_panic(v[66] == 44); + assert_or_panic(v[67] == 45); + assert_or_panic(v[68] == 46); + assert_or_panic(v[69] == 47); + assert_or_panic(v[70] == 48); + assert_or_panic(v[71] == 49); + assert_or_panic(v[72] == 50); + assert_or_panic(v[73] == 51); + assert_or_panic(v[74] == 52); + assert_or_panic(v[75] == 53); + assert_or_panic(v[76] == 54); + assert_or_panic(v[77] == 55); + assert_or_panic(v[78] == 56); + assert_or_panic(v[79] == 57); + assert_or_panic(v[80] == 58); + assert_or_panic(v[81] == 59); + assert_or_panic(v[82] == 60); + assert_or_panic(v[83] == 61); + assert_or_panic(v[84] == 62); + assert_or_panic(v[85] == 63); + assert_or_panic(v[86] == 64); + assert_or_panic(v[87] == 65); + assert_or_panic(v[88] == 66); + assert_or_panic(v[89] == 67); + assert_or_panic(v[90] == 68); + assert_or_panic(v[91] == 69); + assert_or_panic(v[92] == 70); + assert_or_panic(v[93] == 71); + assert_or_panic(v[94] == 72); + assert_or_panic(v[95] == 73); + assert_or_panic(v[96] == 74); + assert_or_panic(v[97] == 75); + assert_or_panic(v[98] == 76); + assert_or_panic(v[99] == 77); + assert_or_panic(v[100] == 78); + assert_or_panic(v[101] == 79); + assert_or_panic(v[102] == 80); + assert_or_panic(v[103] == 81); + assert_or_panic(v[104] == 82); + assert_or_panic(v[105] == 83); + assert_or_panic(v[106] == 84); + assert_or_panic(v[107] == 85); + assert_or_panic(v[108] == 86); + assert_or_panic(v[109] == 87); + assert_or_panic(v[110] == 88); + assert_or_panic(v[111] == 89); + assert_or_panic(v[112] == 90); + assert_or_panic(v[113] == 91); + assert_or_panic(v[114] == 92); + assert_or_panic(v[115] == 93); + assert_or_panic(v[116] == 94); + assert_or_panic(v[117] == 95); + assert_or_panic(v[118] == 96); + assert_or_panic(v[119] == 97); + assert_or_panic(v[120] == 98); + assert_or_panic(v[121] == 99); + assert_or_panic(v[122] == 0); + assert_or_panic(v[123] == 1); + assert_or_panic(v[124] == 2); + assert_or_panic(v[125] == 3); + assert_or_panic(v[126] == 4); + assert_or_panic(v[127] == 5); + assert_or_panic(v[128] == 6); + assert_or_panic(v[129] == 7); + assert_or_panic(v[130] == 8); + assert_or_panic(v[131] == 9); + assert_or_panic(v[132] == 10); + assert_or_panic(v[133] == 11); + assert_or_panic(v[134] == 12); + assert_or_panic(v[135] == 13); + assert_or_panic(v[136] == 14); + assert_or_panic(v[137] == 15); + assert_or_panic(v[138] == 16); + assert_or_panic(v[139] == 17); + assert_or_panic(v[140] == 18); + assert_or_panic(v[141] == 19); + assert_or_panic(v[142] == 20); + assert_or_panic(v[143] == 21); + assert_or_panic(v[144] == 22); + assert_or_panic(v[145] == 23); + assert_or_panic(v[146] == 24); + assert_or_panic(v[147] == 25); + assert_or_panic(v[148] == 26); + assert_or_panic(v[149] == 27); + assert_or_panic(v[150] == 28); + assert_or_panic(v[151] == 29); + assert_or_panic(v[152] == 30); + assert_or_panic(v[153] == 31); + assert_or_panic(v[154] == 32); + assert_or_panic(v[155] == 33); + assert_or_panic(v[156] == 34); + assert_or_panic(v[157] == 35); + assert_or_panic(v[158] == 36); + assert_or_panic(v[159] == 37); + assert_or_panic(v[160] == 38); + assert_or_panic(v[161] == 39); + assert_or_panic(v[162] == 40); + assert_or_panic(v[163] == 41); + assert_or_panic(v[164] == 42); + assert_or_panic(v[165] == 43); + assert_or_panic(v[166] == 44); + assert_or_panic(v[167] == 45); + assert_or_panic(v[168] == 46); + assert_or_panic(v[169] == 47); + assert_or_panic(v[170] == 48); + assert_or_panic(v[171] == 49); + assert_or_panic(v[172] == 50); + assert_or_panic(v[173] == 51); + assert_or_panic(v[174] == 52); + assert_or_panic(v[175] == 53); + assert_or_panic(v[176] == 54); + assert_or_panic(v[177] == 55); + assert_or_panic(v[178] == 56); + assert_or_panic(v[179] == 57); + assert_or_panic(v[180] == 58); + assert_or_panic(v[181] == 59); + assert_or_panic(v[182] == 60); + assert_or_panic(v[183] == 61); + assert_or_panic(v[184] == 62); + assert_or_panic(v[185] == 63); + assert_or_panic(v[186] == 64); + assert_or_panic(v[187] == 65); + assert_or_panic(v[188] == 66); + assert_or_panic(v[189] == 67); + assert_or_panic(v[190] == 68); + assert_or_panic(v[191] == 69); + assert_or_panic(v[192] == 70); + assert_or_panic(v[193] == 71); + assert_or_panic(v[194] == 72); + assert_or_panic(v[195] == 73); + assert_or_panic(v[196] == 74); + assert_or_panic(v[197] == 75); + assert_or_panic(v[198] == 76); + assert_or_panic(v[199] == 77); + assert_or_panic(v[200] == 78); + assert_or_panic(v[201] == 79); + assert_or_panic(v[202] == 80); + assert_or_panic(v[203] == 81); + assert_or_panic(v[204] == 82); + assert_or_panic(v[205] == 83); + assert_or_panic(v[206] == 84); + assert_or_panic(v[207] == 85); + assert_or_panic(v[208] == 86); + assert_or_panic(v[209] == 87); + assert_or_panic(v[210] == 88); + assert_or_panic(v[211] == 89); + assert_or_panic(v[212] == 90); + assert_or_panic(v[213] == 91); + assert_or_panic(v[214] == 92); + assert_or_panic(v[215] == 93); + assert_or_panic(v[216] == 94); + assert_or_panic(v[217] == 95); + assert_or_panic(v[218] == 96); + assert_or_panic(v[219] == 97); + assert_or_panic(v[220] == 98); + assert_or_panic(v[221] == 99); + assert_or_panic(v[222] == 0); + assert_or_panic(v[223] == 1); + assert_or_panic(v[224] == 2); + assert_or_panic(v[225] == 3); + assert_or_panic(v[226] == 4); + assert_or_panic(v[227] == 5); + assert_or_panic(v[228] == 6); + assert_or_panic(v[229] == 7); + assert_or_panic(v[230] == 8); + assert_or_panic(v[231] == 9); + assert_or_panic(v[232] == 10); + assert_or_panic(v[233] == 11); + assert_or_panic(v[234] == 12); + assert_or_panic(v[235] == 13); + assert_or_panic(v[236] == 14); + assert_or_panic(v[237] == 15); + assert_or_panic(v[238] == 16); + assert_or_panic(v[239] == 17); + assert_or_panic(v[240] == 18); + assert_or_panic(v[241] == 19); + assert_or_panic(v[242] == 20); + assert_or_panic(v[243] == 21); + assert_or_panic(v[244] == 22); + assert_or_panic(v[245] == 23); + assert_or_panic(v[246] == 24); + assert_or_panic(v[247] == 25); + assert_or_panic(v[248] == 26); + assert_or_panic(v[249] == 27); + assert_or_panic(v[250] == 28); + assert_or_panic(v[251] == 29); + assert_or_panic(v[252] == 30); + assert_or_panic(v[253] == 31); + assert_or_panic(v[254] == 32); + assert_or_panic(v[255] == 33); + assert_or_panic(v[256] == 34); + assert_or_panic(v[257] == 35); + assert_or_panic(v[258] == 36); + assert_or_panic(v[259] == 37); + assert_or_panic(v[260] == 38); + assert_or_panic(v[261] == 39); + assert_or_panic(v[262] == 40); + assert_or_panic(v[263] == 41); + assert_or_panic(v[264] == 42); + assert_or_panic(v[265] == 43); + assert_or_panic(v[266] == 44); + assert_or_panic(v[267] == 45); + assert_or_panic(v[268] == 46); + assert_or_panic(v[269] == 47); + assert_or_panic(v[270] == 48); + assert_or_panic(v[271] == 49); + assert_or_panic(v[272] == 50); + assert_or_panic(v[273] == 51); + assert_or_panic(v[274] == 52); + assert_or_panic(v[275] == 53); + assert_or_panic(v[276] == 54); + assert_or_panic(v[277] == 55); + assert_or_panic(v[278] == 56); + assert_or_panic(v[279] == 57); + assert_or_panic(v[280] == 58); + assert_or_panic(v[281] == 59); + assert_or_panic(v[282] == 60); + assert_or_panic(v[283] == 61); + assert_or_panic(v[284] == 62); + assert_or_panic(v[285] == 63); + assert_or_panic(v[286] == 64); + assert_or_panic(v[287] == 65); + assert_or_panic(v[288] == 66); + assert_or_panic(v[289] == 67); + assert_or_panic(v[290] == 68); + assert_or_panic(v[291] == 69); + assert_or_panic(v[292] == 70); + assert_or_panic(v[293] == 71); + assert_or_panic(v[294] == 72); + assert_or_panic(v[295] == 73); + assert_or_panic(v[296] == 74); + assert_or_panic(v[297] == 75); + assert_or_panic(v[298] == 76); + assert_or_panic(v[299] == 77); + assert_or_panic(v[300] == 78); + assert_or_panic(v[301] == 79); + assert_or_panic(v[302] == 80); + assert_or_panic(v[303] == 81); + assert_or_panic(v[304] == 82); + assert_or_panic(v[305] == 83); + assert_or_panic(v[306] == 84); + assert_or_panic(v[307] == 85); + assert_or_panic(v[308] == 86); + assert_or_panic(v[309] == 87); + assert_or_panic(v[310] == 88); + assert_or_panic(v[311] == 89); + assert_or_panic(v[312] == 90); + assert_or_panic(v[313] == 91); + assert_or_panic(v[314] == 92); + assert_or_panic(v[315] == 93); + assert_or_panic(v[316] == 94); + assert_or_panic(v[317] == 95); + assert_or_panic(v[318] == 96); + assert_or_panic(v[319] == 97); + assert_or_panic(v[320] == 98); + assert_or_panic(v[321] == 99); + assert_or_panic(v[322] == 0); + assert_or_panic(v[323] == 1); + assert_or_panic(v[324] == 2); + assert_or_panic(v[325] == 3); + assert_or_panic(v[326] == 4); + assert_or_panic(v[327] == 5); + assert_or_panic(v[328] == 6); + assert_or_panic(v[329] == 7); + assert_or_panic(v[330] == 8); + assert_or_panic(v[331] == 9); + assert_or_panic(v[332] == 10); + assert_or_panic(v[333] == 11); + assert_or_panic(v[334] == 12); + assert_or_panic(v[335] == 13); + assert_or_panic(v[336] == 14); + assert_or_panic(v[337] == 15); + assert_or_panic(v[338] == 16); + assert_or_panic(v[339] == 17); + assert_or_panic(v[340] == 18); + assert_or_panic(v[341] == 19); + assert_or_panic(v[342] == 20); + assert_or_panic(v[343] == 21); + assert_or_panic(v[344] == 22); + assert_or_panic(v[345] == 23); + assert_or_panic(v[346] == 24); + assert_or_panic(v[347] == 25); + assert_or_panic(v[348] == 26); + assert_or_panic(v[349] == 27); + assert_or_panic(v[350] == 28); + assert_or_panic(v[351] == 29); + assert_or_panic(v[352] == 30); + assert_or_panic(v[353] == 31); + assert_or_panic(v[354] == 32); + assert_or_panic(v[355] == 33); + assert_or_panic(v[356] == 34); + assert_or_panic(v[357] == 35); + assert_or_panic(v[358] == 36); + assert_or_panic(v[359] == 37); + assert_or_panic(v[360] == 38); + assert_or_panic(v[361] == 39); + assert_or_panic(v[362] == 40); + assert_or_panic(v[363] == 41); + assert_or_panic(v[364] == 42); + assert_or_panic(v[365] == 43); + assert_or_panic(v[366] == 44); + assert_or_panic(v[367] == 45); + assert_or_panic(v[368] == 46); + assert_or_panic(v[369] == 47); + assert_or_panic(v[370] == 48); + assert_or_panic(v[371] == 49); + assert_or_panic(v[372] == 50); + assert_or_panic(v[373] == 51); + assert_or_panic(v[374] == 52); + assert_or_panic(v[375] == 53); + assert_or_panic(v[376] == 54); + assert_or_panic(v[377] == 55); + assert_or_panic(v[378] == 56); + assert_or_panic(v[379] == 57); + assert_or_panic(v[380] == 58); + assert_or_panic(v[381] == 59); + assert_or_panic(v[382] == 60); + assert_or_panic(v[383] == 61); + zig_vector_384_u8((Vector_384_u8){ + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + }, 384); +} + +typedef uint8_t Vector_512_u8 __attribute__((vector_size(512 * sizeof(uint8_t)))); + +Vector_512_u8 zig_ret_vector_512_u8(void); +void zig_vector_512_u8(Vector_512_u8, size_t); + +Vector_512_u8 c_ret_vector_512_u8(void) { + return (Vector_512_u8){ + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + }; +} +void c_vector_512_u8(Vector_512_u8 v, size_t i) { + assert_or_panic(v[0] == 50); + assert_or_panic(v[1] == 51); + assert_or_panic(v[2] == 52); + assert_or_panic(v[3] == 53); + assert_or_panic(v[4] == 54); + assert_or_panic(v[5] == 55); + assert_or_panic(v[6] == 56); + assert_or_panic(v[7] == 57); + assert_or_panic(v[8] == 58); + assert_or_panic(v[9] == 59); + assert_or_panic(v[10] == 60); + assert_or_panic(v[11] == 61); + assert_or_panic(v[12] == 62); + assert_or_panic(v[13] == 63); + assert_or_panic(v[14] == 64); + assert_or_panic(v[15] == 65); + assert_or_panic(v[16] == 66); + assert_or_panic(v[17] == 67); + assert_or_panic(v[18] == 68); + assert_or_panic(v[19] == 69); + assert_or_panic(v[20] == 70); + assert_or_panic(v[21] == 71); + assert_or_panic(v[22] == 72); + assert_or_panic(v[23] == 73); + assert_or_panic(v[24] == 74); + assert_or_panic(v[25] == 75); + assert_or_panic(v[26] == 76); + assert_or_panic(v[27] == 77); + assert_or_panic(v[28] == 78); + assert_or_panic(v[29] == 79); + assert_or_panic(v[30] == 80); + assert_or_panic(v[31] == 81); + assert_or_panic(v[32] == 82); + assert_or_panic(v[33] == 83); + assert_or_panic(v[34] == 84); + assert_or_panic(v[35] == 85); + assert_or_panic(v[36] == 86); + assert_or_panic(v[37] == 87); + assert_or_panic(v[38] == 88); + assert_or_panic(v[39] == 89); + assert_or_panic(v[40] == 90); + assert_or_panic(v[41] == 91); + assert_or_panic(v[42] == 92); + assert_or_panic(v[43] == 93); + assert_or_panic(v[44] == 94); + assert_or_panic(v[45] == 95); + assert_or_panic(v[46] == 96); + assert_or_panic(v[47] == 97); + assert_or_panic(v[48] == 98); + assert_or_panic(v[49] == 99); + assert_or_panic(v[50] == 0); + assert_or_panic(v[51] == 1); + assert_or_panic(v[52] == 2); + assert_or_panic(v[53] == 3); + assert_or_panic(v[54] == 4); + assert_or_panic(v[55] == 5); + assert_or_panic(v[56] == 6); + assert_or_panic(v[57] == 7); + assert_or_panic(v[58] == 8); + assert_or_panic(v[59] == 9); + assert_or_panic(v[60] == 10); + assert_or_panic(v[61] == 11); + assert_or_panic(v[62] == 12); + assert_or_panic(v[63] == 13); + assert_or_panic(v[64] == 14); + assert_or_panic(v[65] == 15); + assert_or_panic(v[66] == 16); + assert_or_panic(v[67] == 17); + assert_or_panic(v[68] == 18); + assert_or_panic(v[69] == 19); + assert_or_panic(v[70] == 20); + assert_or_panic(v[71] == 21); + assert_or_panic(v[72] == 22); + assert_or_panic(v[73] == 23); + assert_or_panic(v[74] == 24); + assert_or_panic(v[75] == 25); + assert_or_panic(v[76] == 26); + assert_or_panic(v[77] == 27); + assert_or_panic(v[78] == 28); + assert_or_panic(v[79] == 29); + assert_or_panic(v[80] == 30); + assert_or_panic(v[81] == 31); + assert_or_panic(v[82] == 32); + assert_or_panic(v[83] == 33); + assert_or_panic(v[84] == 34); + assert_or_panic(v[85] == 35); + assert_or_panic(v[86] == 36); + assert_or_panic(v[87] == 37); + assert_or_panic(v[88] == 38); + assert_or_panic(v[89] == 39); + assert_or_panic(v[90] == 40); + assert_or_panic(v[91] == 41); + assert_or_panic(v[92] == 42); + assert_or_panic(v[93] == 43); + assert_or_panic(v[94] == 44); + assert_or_panic(v[95] == 45); + assert_or_panic(v[96] == 46); + assert_or_panic(v[97] == 47); + assert_or_panic(v[98] == 48); + assert_or_panic(v[99] == 49); + assert_or_panic(v[100] == 50); + assert_or_panic(v[101] == 51); + assert_or_panic(v[102] == 52); + assert_or_panic(v[103] == 53); + assert_or_panic(v[104] == 54); + assert_or_panic(v[105] == 55); + assert_or_panic(v[106] == 56); + assert_or_panic(v[107] == 57); + assert_or_panic(v[108] == 58); + assert_or_panic(v[109] == 59); + assert_or_panic(v[110] == 60); + assert_or_panic(v[111] == 61); + assert_or_panic(v[112] == 62); + assert_or_panic(v[113] == 63); + assert_or_panic(v[114] == 64); + assert_or_panic(v[115] == 65); + assert_or_panic(v[116] == 66); + assert_or_panic(v[117] == 67); + assert_or_panic(v[118] == 68); + assert_or_panic(v[119] == 69); + assert_or_panic(v[120] == 70); + assert_or_panic(v[121] == 71); + assert_or_panic(v[122] == 72); + assert_or_panic(v[123] == 73); + assert_or_panic(v[124] == 74); + assert_or_panic(v[125] == 75); + assert_or_panic(v[126] == 76); + assert_or_panic(v[127] == 77); + assert_or_panic(v[128] == 78); + assert_or_panic(v[129] == 79); + assert_or_panic(v[130] == 80); + assert_or_panic(v[131] == 81); + assert_or_panic(v[132] == 82); + assert_or_panic(v[133] == 83); + assert_or_panic(v[134] == 84); + assert_or_panic(v[135] == 85); + assert_or_panic(v[136] == 86); + assert_or_panic(v[137] == 87); + assert_or_panic(v[138] == 88); + assert_or_panic(v[139] == 89); + assert_or_panic(v[140] == 90); + assert_or_panic(v[141] == 91); + assert_or_panic(v[142] == 92); + assert_or_panic(v[143] == 93); + assert_or_panic(v[144] == 94); + assert_or_panic(v[145] == 95); + assert_or_panic(v[146] == 96); + assert_or_panic(v[147] == 97); + assert_or_panic(v[148] == 98); + assert_or_panic(v[149] == 99); + assert_or_panic(v[150] == 0); + assert_or_panic(v[151] == 1); + assert_or_panic(v[152] == 2); + assert_or_panic(v[153] == 3); + assert_or_panic(v[154] == 4); + assert_or_panic(v[155] == 5); + assert_or_panic(v[156] == 6); + assert_or_panic(v[157] == 7); + assert_or_panic(v[158] == 8); + assert_or_panic(v[159] == 9); + assert_or_panic(v[160] == 10); + assert_or_panic(v[161] == 11); + assert_or_panic(v[162] == 12); + assert_or_panic(v[163] == 13); + assert_or_panic(v[164] == 14); + assert_or_panic(v[165] == 15); + assert_or_panic(v[166] == 16); + assert_or_panic(v[167] == 17); + assert_or_panic(v[168] == 18); + assert_or_panic(v[169] == 19); + assert_or_panic(v[170] == 20); + assert_or_panic(v[171] == 21); + assert_or_panic(v[172] == 22); + assert_or_panic(v[173] == 23); + assert_or_panic(v[174] == 24); + assert_or_panic(v[175] == 25); + assert_or_panic(v[176] == 26); + assert_or_panic(v[177] == 27); + assert_or_panic(v[178] == 28); + assert_or_panic(v[179] == 29); + assert_or_panic(v[180] == 30); + assert_or_panic(v[181] == 31); + assert_or_panic(v[182] == 32); + assert_or_panic(v[183] == 33); + assert_or_panic(v[184] == 34); + assert_or_panic(v[185] == 35); + assert_or_panic(v[186] == 36); + assert_or_panic(v[187] == 37); + assert_or_panic(v[188] == 38); + assert_or_panic(v[189] == 39); + assert_or_panic(v[190] == 40); + assert_or_panic(v[191] == 41); + assert_or_panic(v[192] == 42); + assert_or_panic(v[193] == 43); + assert_or_panic(v[194] == 44); + assert_or_panic(v[195] == 45); + assert_or_panic(v[196] == 46); + assert_or_panic(v[197] == 47); + assert_or_panic(v[198] == 48); + assert_or_panic(v[199] == 49); + assert_or_panic(v[200] == 50); + assert_or_panic(v[201] == 51); + assert_or_panic(v[202] == 52); + assert_or_panic(v[203] == 53); + assert_or_panic(v[204] == 54); + assert_or_panic(v[205] == 55); + assert_or_panic(v[206] == 56); + assert_or_panic(v[207] == 57); + assert_or_panic(v[208] == 58); + assert_or_panic(v[209] == 59); + assert_or_panic(v[210] == 60); + assert_or_panic(v[211] == 61); + assert_or_panic(v[212] == 62); + assert_or_panic(v[213] == 63); + assert_or_panic(v[214] == 64); + assert_or_panic(v[215] == 65); + assert_or_panic(v[216] == 66); + assert_or_panic(v[217] == 67); + assert_or_panic(v[218] == 68); + assert_or_panic(v[219] == 69); + assert_or_panic(v[220] == 70); + assert_or_panic(v[221] == 71); + assert_or_panic(v[222] == 72); + assert_or_panic(v[223] == 73); + assert_or_panic(v[224] == 74); + assert_or_panic(v[225] == 75); + assert_or_panic(v[226] == 76); + assert_or_panic(v[227] == 77); + assert_or_panic(v[228] == 78); + assert_or_panic(v[229] == 79); + assert_or_panic(v[230] == 80); + assert_or_panic(v[231] == 81); + assert_or_panic(v[232] == 82); + assert_or_panic(v[233] == 83); + assert_or_panic(v[234] == 84); + assert_or_panic(v[235] == 85); + assert_or_panic(v[236] == 86); + assert_or_panic(v[237] == 87); + assert_or_panic(v[238] == 88); + assert_or_panic(v[239] == 89); + assert_or_panic(v[240] == 90); + assert_or_panic(v[241] == 91); + assert_or_panic(v[242] == 92); + assert_or_panic(v[243] == 93); + assert_or_panic(v[244] == 94); + assert_or_panic(v[245] == 95); + assert_or_panic(v[246] == 96); + assert_or_panic(v[247] == 97); + assert_or_panic(v[248] == 98); + assert_or_panic(v[249] == 99); + assert_or_panic(v[250] == 0); + assert_or_panic(v[251] == 1); + assert_or_panic(v[252] == 2); + assert_or_panic(v[253] == 3); + assert_or_panic(v[254] == 4); + assert_or_panic(v[255] == 5); + assert_or_panic(v[256] == 6); + assert_or_panic(v[257] == 7); + assert_or_panic(v[258] == 8); + assert_or_panic(v[259] == 9); + assert_or_panic(v[260] == 10); + assert_or_panic(v[261] == 11); + assert_or_panic(v[262] == 12); + assert_or_panic(v[263] == 13); + assert_or_panic(v[264] == 14); + assert_or_panic(v[265] == 15); + assert_or_panic(v[266] == 16); + assert_or_panic(v[267] == 17); + assert_or_panic(v[268] == 18); + assert_or_panic(v[269] == 19); + assert_or_panic(v[270] == 20); + assert_or_panic(v[271] == 21); + assert_or_panic(v[272] == 22); + assert_or_panic(v[273] == 23); + assert_or_panic(v[274] == 24); + assert_or_panic(v[275] == 25); + assert_or_panic(v[276] == 26); + assert_or_panic(v[277] == 27); + assert_or_panic(v[278] == 28); + assert_or_panic(v[279] == 29); + assert_or_panic(v[280] == 30); + assert_or_panic(v[281] == 31); + assert_or_panic(v[282] == 32); + assert_or_panic(v[283] == 33); + assert_or_panic(v[284] == 34); + assert_or_panic(v[285] == 35); + assert_or_panic(v[286] == 36); + assert_or_panic(v[287] == 37); + assert_or_panic(v[288] == 38); + assert_or_panic(v[289] == 39); + assert_or_panic(v[290] == 40); + assert_or_panic(v[291] == 41); + assert_or_panic(v[292] == 42); + assert_or_panic(v[293] == 43); + assert_or_panic(v[294] == 44); + assert_or_panic(v[295] == 45); + assert_or_panic(v[296] == 46); + assert_or_panic(v[297] == 47); + assert_or_panic(v[298] == 48); + assert_or_panic(v[299] == 49); + assert_or_panic(v[300] == 50); + assert_or_panic(v[301] == 51); + assert_or_panic(v[302] == 52); + assert_or_panic(v[303] == 53); + assert_or_panic(v[304] == 54); + assert_or_panic(v[305] == 55); + assert_or_panic(v[306] == 56); + assert_or_panic(v[307] == 57); + assert_or_panic(v[308] == 58); + assert_or_panic(v[309] == 59); + assert_or_panic(v[310] == 60); + assert_or_panic(v[311] == 61); + assert_or_panic(v[312] == 62); + assert_or_panic(v[313] == 63); + assert_or_panic(v[314] == 64); + assert_or_panic(v[315] == 65); + assert_or_panic(v[316] == 66); + assert_or_panic(v[317] == 67); + assert_or_panic(v[318] == 68); + assert_or_panic(v[319] == 69); + assert_or_panic(v[320] == 70); + assert_or_panic(v[321] == 71); + assert_or_panic(v[322] == 72); + assert_or_panic(v[323] == 73); + assert_or_panic(v[324] == 74); + assert_or_panic(v[325] == 75); + assert_or_panic(v[326] == 76); + assert_or_panic(v[327] == 77); + assert_or_panic(v[328] == 78); + assert_or_panic(v[329] == 79); + assert_or_panic(v[330] == 80); + assert_or_panic(v[331] == 81); + assert_or_panic(v[332] == 82); + assert_or_panic(v[333] == 83); + assert_or_panic(v[334] == 84); + assert_or_panic(v[335] == 85); + assert_or_panic(v[336] == 86); + assert_or_panic(v[337] == 87); + assert_or_panic(v[338] == 88); + assert_or_panic(v[339] == 89); + assert_or_panic(v[340] == 90); + assert_or_panic(v[341] == 91); + assert_or_panic(v[342] == 92); + assert_or_panic(v[343] == 93); + assert_or_panic(v[344] == 94); + assert_or_panic(v[345] == 95); + assert_or_panic(v[346] == 96); + assert_or_panic(v[347] == 97); + assert_or_panic(v[348] == 98); + assert_or_panic(v[349] == 99); + assert_or_panic(v[350] == 0); + assert_or_panic(v[351] == 1); + assert_or_panic(v[352] == 2); + assert_or_panic(v[353] == 3); + assert_or_panic(v[354] == 4); + assert_or_panic(v[355] == 5); + assert_or_panic(v[356] == 6); + assert_or_panic(v[357] == 7); + assert_or_panic(v[358] == 8); + assert_or_panic(v[359] == 9); + assert_or_panic(v[360] == 10); + assert_or_panic(v[361] == 11); + assert_or_panic(v[362] == 12); + assert_or_panic(v[363] == 13); + assert_or_panic(v[364] == 14); + assert_or_panic(v[365] == 15); + assert_or_panic(v[366] == 16); + assert_or_panic(v[367] == 17); + assert_or_panic(v[368] == 18); + assert_or_panic(v[369] == 19); + assert_or_panic(v[370] == 20); + assert_or_panic(v[371] == 21); + assert_or_panic(v[372] == 22); + assert_or_panic(v[373] == 23); + assert_or_panic(v[374] == 24); + assert_or_panic(v[375] == 25); + assert_or_panic(v[376] == 26); + assert_or_panic(v[377] == 27); + assert_or_panic(v[378] == 28); + assert_or_panic(v[379] == 29); + assert_or_panic(v[380] == 30); + assert_or_panic(v[381] == 31); + assert_or_panic(v[382] == 32); + assert_or_panic(v[383] == 33); + assert_or_panic(v[384] == 34); + assert_or_panic(v[385] == 35); + assert_or_panic(v[386] == 36); + assert_or_panic(v[387] == 37); + assert_or_panic(v[388] == 38); + assert_or_panic(v[389] == 39); + assert_or_panic(v[390] == 40); + assert_or_panic(v[391] == 41); + assert_or_panic(v[392] == 42); + assert_or_panic(v[393] == 43); + assert_or_panic(v[394] == 44); + assert_or_panic(v[395] == 45); + assert_or_panic(v[396] == 46); + assert_or_panic(v[397] == 47); + assert_or_panic(v[398] == 48); + assert_or_panic(v[399] == 49); + assert_or_panic(v[400] == 50); + assert_or_panic(v[401] == 51); + assert_or_panic(v[402] == 52); + assert_or_panic(v[403] == 53); + assert_or_panic(v[404] == 54); + assert_or_panic(v[405] == 55); + assert_or_panic(v[406] == 56); + assert_or_panic(v[407] == 57); + assert_or_panic(v[408] == 58); + assert_or_panic(v[409] == 59); + assert_or_panic(v[410] == 60); + assert_or_panic(v[411] == 61); + assert_or_panic(v[412] == 62); + assert_or_panic(v[413] == 63); + assert_or_panic(v[414] == 64); + assert_or_panic(v[415] == 65); + assert_or_panic(v[416] == 66); + assert_or_panic(v[417] == 67); + assert_or_panic(v[418] == 68); + assert_or_panic(v[419] == 69); + assert_or_panic(v[420] == 70); + assert_or_panic(v[421] == 71); + assert_or_panic(v[422] == 72); + assert_or_panic(v[423] == 73); + assert_or_panic(v[424] == 74); + assert_or_panic(v[425] == 75); + assert_or_panic(v[426] == 76); + assert_or_panic(v[427] == 77); + assert_or_panic(v[428] == 78); + assert_or_panic(v[429] == 79); + assert_or_panic(v[430] == 80); + assert_or_panic(v[431] == 81); + assert_or_panic(v[432] == 82); + assert_or_panic(v[433] == 83); + assert_or_panic(v[434] == 84); + assert_or_panic(v[435] == 85); + assert_or_panic(v[436] == 86); + assert_or_panic(v[437] == 87); + assert_or_panic(v[438] == 88); + assert_or_panic(v[439] == 89); + assert_or_panic(v[440] == 90); + assert_or_panic(v[441] == 91); + assert_or_panic(v[442] == 92); + assert_or_panic(v[443] == 93); + assert_or_panic(v[444] == 94); + assert_or_panic(v[445] == 95); + assert_or_panic(v[446] == 96); + assert_or_panic(v[447] == 97); + assert_or_panic(v[448] == 98); + assert_or_panic(v[449] == 99); + assert_or_panic(v[450] == 0); + assert_or_panic(v[451] == 1); + assert_or_panic(v[452] == 2); + assert_or_panic(v[453] == 3); + assert_or_panic(v[454] == 4); + assert_or_panic(v[455] == 5); + assert_or_panic(v[456] == 6); + assert_or_panic(v[457] == 7); + assert_or_panic(v[458] == 8); + assert_or_panic(v[459] == 9); + assert_or_panic(v[460] == 10); + assert_or_panic(v[461] == 11); + assert_or_panic(v[462] == 12); + assert_or_panic(v[463] == 13); + assert_or_panic(v[464] == 14); + assert_or_panic(v[465] == 15); + assert_or_panic(v[466] == 16); + assert_or_panic(v[467] == 17); + assert_or_panic(v[468] == 18); + assert_or_panic(v[469] == 19); + assert_or_panic(v[470] == 20); + assert_or_panic(v[471] == 21); + assert_or_panic(v[472] == 22); + assert_or_panic(v[473] == 23); + assert_or_panic(v[474] == 24); + assert_or_panic(v[475] == 25); + assert_or_panic(v[476] == 26); + assert_or_panic(v[477] == 27); + assert_or_panic(v[478] == 28); + assert_or_panic(v[479] == 29); + assert_or_panic(v[480] == 30); + assert_or_panic(v[481] == 31); + assert_or_panic(v[482] == 32); + assert_or_panic(v[483] == 33); + assert_or_panic(v[484] == 34); + assert_or_panic(v[485] == 35); + assert_or_panic(v[486] == 36); + assert_or_panic(v[487] == 37); + assert_or_panic(v[488] == 38); + assert_or_panic(v[489] == 39); + assert_or_panic(v[490] == 40); + assert_or_panic(v[491] == 41); + assert_or_panic(v[492] == 42); + assert_or_panic(v[493] == 43); + assert_or_panic(v[494] == 44); + assert_or_panic(v[495] == 45); + assert_or_panic(v[496] == 46); + assert_or_panic(v[497] == 47); + assert_or_panic(v[498] == 48); + assert_or_panic(v[499] == 49); + assert_or_panic(v[500] == 50); + assert_or_panic(v[501] == 51); + assert_or_panic(v[502] == 52); + assert_or_panic(v[503] == 53); + assert_or_panic(v[504] == 54); + assert_or_panic(v[505] == 55); + assert_or_panic(v[506] == 56); + assert_or_panic(v[507] == 57); + assert_or_panic(v[508] == 58); + assert_or_panic(v[509] == 59); + assert_or_panic(v[510] == 60); + assert_or_panic(v[511] == 61); + assert_or_panic(i == 512); +} +void c_test_vector_512_u8(void) { + Vector_512_u8 v = zig_ret_vector_512_u8(); + assert_or_panic(v[0] == 14); + assert_or_panic(v[1] == 15); + assert_or_panic(v[2] == 16); + assert_or_panic(v[3] == 17); + assert_or_panic(v[4] == 18); + assert_or_panic(v[5] == 19); + assert_or_panic(v[6] == 20); + assert_or_panic(v[7] == 21); + assert_or_panic(v[8] == 22); + assert_or_panic(v[9] == 23); + assert_or_panic(v[10] == 24); + assert_or_panic(v[11] == 25); + assert_or_panic(v[12] == 26); + assert_or_panic(v[13] == 27); + assert_or_panic(v[14] == 28); + assert_or_panic(v[15] == 29); + assert_or_panic(v[16] == 30); + assert_or_panic(v[17] == 31); + assert_or_panic(v[18] == 32); + assert_or_panic(v[19] == 33); + assert_or_panic(v[20] == 34); + assert_or_panic(v[21] == 35); + assert_or_panic(v[22] == 36); + assert_or_panic(v[23] == 37); + assert_or_panic(v[24] == 38); + assert_or_panic(v[25] == 39); + assert_or_panic(v[26] == 40); + assert_or_panic(v[27] == 41); + assert_or_panic(v[28] == 42); + assert_or_panic(v[29] == 43); + assert_or_panic(v[30] == 44); + assert_or_panic(v[31] == 45); + assert_or_panic(v[32] == 46); + assert_or_panic(v[33] == 47); + assert_or_panic(v[34] == 48); + assert_or_panic(v[35] == 49); + assert_or_panic(v[36] == 50); + assert_or_panic(v[37] == 51); + assert_or_panic(v[38] == 52); + assert_or_panic(v[39] == 53); + assert_or_panic(v[40] == 54); + assert_or_panic(v[41] == 55); + assert_or_panic(v[42] == 56); + assert_or_panic(v[43] == 57); + assert_or_panic(v[44] == 58); + assert_or_panic(v[45] == 59); + assert_or_panic(v[46] == 60); + assert_or_panic(v[47] == 61); + assert_or_panic(v[48] == 62); + assert_or_panic(v[49] == 63); + assert_or_panic(v[50] == 64); + assert_or_panic(v[51] == 65); + assert_or_panic(v[52] == 66); + assert_or_panic(v[53] == 67); + assert_or_panic(v[54] == 68); + assert_or_panic(v[55] == 69); + assert_or_panic(v[56] == 70); + assert_or_panic(v[57] == 71); + assert_or_panic(v[58] == 72); + assert_or_panic(v[59] == 73); + assert_or_panic(v[60] == 74); + assert_or_panic(v[61] == 75); + assert_or_panic(v[62] == 76); + assert_or_panic(v[63] == 77); + assert_or_panic(v[64] == 78); + assert_or_panic(v[65] == 79); + assert_or_panic(v[66] == 80); + assert_or_panic(v[67] == 81); + assert_or_panic(v[68] == 82); + assert_or_panic(v[69] == 83); + assert_or_panic(v[70] == 84); + assert_or_panic(v[71] == 85); + assert_or_panic(v[72] == 86); + assert_or_panic(v[73] == 87); + assert_or_panic(v[74] == 88); + assert_or_panic(v[75] == 89); + assert_or_panic(v[76] == 90); + assert_or_panic(v[77] == 91); + assert_or_panic(v[78] == 92); + assert_or_panic(v[79] == 93); + assert_or_panic(v[80] == 94); + assert_or_panic(v[81] == 95); + assert_or_panic(v[82] == 96); + assert_or_panic(v[83] == 97); + assert_or_panic(v[84] == 98); + assert_or_panic(v[85] == 99); + assert_or_panic(v[86] == 0); + assert_or_panic(v[87] == 1); + assert_or_panic(v[88] == 2); + assert_or_panic(v[89] == 3); + assert_or_panic(v[90] == 4); + assert_or_panic(v[91] == 5); + assert_or_panic(v[92] == 6); + assert_or_panic(v[93] == 7); + assert_or_panic(v[94] == 8); + assert_or_panic(v[95] == 9); + assert_or_panic(v[96] == 10); + assert_or_panic(v[97] == 11); + assert_or_panic(v[98] == 12); + assert_or_panic(v[99] == 13); + assert_or_panic(v[100] == 14); + assert_or_panic(v[101] == 15); + assert_or_panic(v[102] == 16); + assert_or_panic(v[103] == 17); + assert_or_panic(v[104] == 18); + assert_or_panic(v[105] == 19); + assert_or_panic(v[106] == 20); + assert_or_panic(v[107] == 21); + assert_or_panic(v[108] == 22); + assert_or_panic(v[109] == 23); + assert_or_panic(v[110] == 24); + assert_or_panic(v[111] == 25); + assert_or_panic(v[112] == 26); + assert_or_panic(v[113] == 27); + assert_or_panic(v[114] == 28); + assert_or_panic(v[115] == 29); + assert_or_panic(v[116] == 30); + assert_or_panic(v[117] == 31); + assert_or_panic(v[118] == 32); + assert_or_panic(v[119] == 33); + assert_or_panic(v[120] == 34); + assert_or_panic(v[121] == 35); + assert_or_panic(v[122] == 36); + assert_or_panic(v[123] == 37); + assert_or_panic(v[124] == 38); + assert_or_panic(v[125] == 39); + assert_or_panic(v[126] == 40); + assert_or_panic(v[127] == 41); + assert_or_panic(v[128] == 42); + assert_or_panic(v[129] == 43); + assert_or_panic(v[130] == 44); + assert_or_panic(v[131] == 45); + assert_or_panic(v[132] == 46); + assert_or_panic(v[133] == 47); + assert_or_panic(v[134] == 48); + assert_or_panic(v[135] == 49); + assert_or_panic(v[136] == 50); + assert_or_panic(v[137] == 51); + assert_or_panic(v[138] == 52); + assert_or_panic(v[139] == 53); + assert_or_panic(v[140] == 54); + assert_or_panic(v[141] == 55); + assert_or_panic(v[142] == 56); + assert_or_panic(v[143] == 57); + assert_or_panic(v[144] == 58); + assert_or_panic(v[145] == 59); + assert_or_panic(v[146] == 60); + assert_or_panic(v[147] == 61); + assert_or_panic(v[148] == 62); + assert_or_panic(v[149] == 63); + assert_or_panic(v[150] == 64); + assert_or_panic(v[151] == 65); + assert_or_panic(v[152] == 66); + assert_or_panic(v[153] == 67); + assert_or_panic(v[154] == 68); + assert_or_panic(v[155] == 69); + assert_or_panic(v[156] == 70); + assert_or_panic(v[157] == 71); + assert_or_panic(v[158] == 72); + assert_or_panic(v[159] == 73); + assert_or_panic(v[160] == 74); + assert_or_panic(v[161] == 75); + assert_or_panic(v[162] == 76); + assert_or_panic(v[163] == 77); + assert_or_panic(v[164] == 78); + assert_or_panic(v[165] == 79); + assert_or_panic(v[166] == 80); + assert_or_panic(v[167] == 81); + assert_or_panic(v[168] == 82); + assert_or_panic(v[169] == 83); + assert_or_panic(v[170] == 84); + assert_or_panic(v[171] == 85); + assert_or_panic(v[172] == 86); + assert_or_panic(v[173] == 87); + assert_or_panic(v[174] == 88); + assert_or_panic(v[175] == 89); + assert_or_panic(v[176] == 90); + assert_or_panic(v[177] == 91); + assert_or_panic(v[178] == 92); + assert_or_panic(v[179] == 93); + assert_or_panic(v[180] == 94); + assert_or_panic(v[181] == 95); + assert_or_panic(v[182] == 96); + assert_or_panic(v[183] == 97); + assert_or_panic(v[184] == 98); + assert_or_panic(v[185] == 99); + assert_or_panic(v[186] == 0); + assert_or_panic(v[187] == 1); + assert_or_panic(v[188] == 2); + assert_or_panic(v[189] == 3); + assert_or_panic(v[190] == 4); + assert_or_panic(v[191] == 5); + assert_or_panic(v[192] == 6); + assert_or_panic(v[193] == 7); + assert_or_panic(v[194] == 8); + assert_or_panic(v[195] == 9); + assert_or_panic(v[196] == 10); + assert_or_panic(v[197] == 11); + assert_or_panic(v[198] == 12); + assert_or_panic(v[199] == 13); + assert_or_panic(v[200] == 14); + assert_or_panic(v[201] == 15); + assert_or_panic(v[202] == 16); + assert_or_panic(v[203] == 17); + assert_or_panic(v[204] == 18); + assert_or_panic(v[205] == 19); + assert_or_panic(v[206] == 20); + assert_or_panic(v[207] == 21); + assert_or_panic(v[208] == 22); + assert_or_panic(v[209] == 23); + assert_or_panic(v[210] == 24); + assert_or_panic(v[211] == 25); + assert_or_panic(v[212] == 26); + assert_or_panic(v[213] == 27); + assert_or_panic(v[214] == 28); + assert_or_panic(v[215] == 29); + assert_or_panic(v[216] == 30); + assert_or_panic(v[217] == 31); + assert_or_panic(v[218] == 32); + assert_or_panic(v[219] == 33); + assert_or_panic(v[220] == 34); + assert_or_panic(v[221] == 35); + assert_or_panic(v[222] == 36); + assert_or_panic(v[223] == 37); + assert_or_panic(v[224] == 38); + assert_or_panic(v[225] == 39); + assert_or_panic(v[226] == 40); + assert_or_panic(v[227] == 41); + assert_or_panic(v[228] == 42); + assert_or_panic(v[229] == 43); + assert_or_panic(v[230] == 44); + assert_or_panic(v[231] == 45); + assert_or_panic(v[232] == 46); + assert_or_panic(v[233] == 47); + assert_or_panic(v[234] == 48); + assert_or_panic(v[235] == 49); + assert_or_panic(v[236] == 50); + assert_or_panic(v[237] == 51); + assert_or_panic(v[238] == 52); + assert_or_panic(v[239] == 53); + assert_or_panic(v[240] == 54); + assert_or_panic(v[241] == 55); + assert_or_panic(v[242] == 56); + assert_or_panic(v[243] == 57); + assert_or_panic(v[244] == 58); + assert_or_panic(v[245] == 59); + assert_or_panic(v[246] == 60); + assert_or_panic(v[247] == 61); + assert_or_panic(v[248] == 62); + assert_or_panic(v[249] == 63); + assert_or_panic(v[250] == 64); + assert_or_panic(v[251] == 65); + assert_or_panic(v[252] == 66); + assert_or_panic(v[253] == 67); + assert_or_panic(v[254] == 68); + assert_or_panic(v[255] == 69); + assert_or_panic(v[256] == 70); + assert_or_panic(v[257] == 71); + assert_or_panic(v[258] == 72); + assert_or_panic(v[259] == 73); + assert_or_panic(v[260] == 74); + assert_or_panic(v[261] == 75); + assert_or_panic(v[262] == 76); + assert_or_panic(v[263] == 77); + assert_or_panic(v[264] == 78); + assert_or_panic(v[265] == 79); + assert_or_panic(v[266] == 80); + assert_or_panic(v[267] == 81); + assert_or_panic(v[268] == 82); + assert_or_panic(v[269] == 83); + assert_or_panic(v[270] == 84); + assert_or_panic(v[271] == 85); + assert_or_panic(v[272] == 86); + assert_or_panic(v[273] == 87); + assert_or_panic(v[274] == 88); + assert_or_panic(v[275] == 89); + assert_or_panic(v[276] == 90); + assert_or_panic(v[277] == 91); + assert_or_panic(v[278] == 92); + assert_or_panic(v[279] == 93); + assert_or_panic(v[280] == 94); + assert_or_panic(v[281] == 95); + assert_or_panic(v[282] == 96); + assert_or_panic(v[283] == 97); + assert_or_panic(v[284] == 98); + assert_or_panic(v[285] == 99); + assert_or_panic(v[286] == 0); + assert_or_panic(v[287] == 1); + assert_or_panic(v[288] == 2); + assert_or_panic(v[289] == 3); + assert_or_panic(v[290] == 4); + assert_or_panic(v[291] == 5); + assert_or_panic(v[292] == 6); + assert_or_panic(v[293] == 7); + assert_or_panic(v[294] == 8); + assert_or_panic(v[295] == 9); + assert_or_panic(v[296] == 10); + assert_or_panic(v[297] == 11); + assert_or_panic(v[298] == 12); + assert_or_panic(v[299] == 13); + assert_or_panic(v[300] == 14); + assert_or_panic(v[301] == 15); + assert_or_panic(v[302] == 16); + assert_or_panic(v[303] == 17); + assert_or_panic(v[304] == 18); + assert_or_panic(v[305] == 19); + assert_or_panic(v[306] == 20); + assert_or_panic(v[307] == 21); + assert_or_panic(v[308] == 22); + assert_or_panic(v[309] == 23); + assert_or_panic(v[310] == 24); + assert_or_panic(v[311] == 25); + assert_or_panic(v[312] == 26); + assert_or_panic(v[313] == 27); + assert_or_panic(v[314] == 28); + assert_or_panic(v[315] == 29); + assert_or_panic(v[316] == 30); + assert_or_panic(v[317] == 31); + assert_or_panic(v[318] == 32); + assert_or_panic(v[319] == 33); + assert_or_panic(v[320] == 34); + assert_or_panic(v[321] == 35); + assert_or_panic(v[322] == 36); + assert_or_panic(v[323] == 37); + assert_or_panic(v[324] == 38); + assert_or_panic(v[325] == 39); + assert_or_panic(v[326] == 40); + assert_or_panic(v[327] == 41); + assert_or_panic(v[328] == 42); + assert_or_panic(v[329] == 43); + assert_or_panic(v[330] == 44); + assert_or_panic(v[331] == 45); + assert_or_panic(v[332] == 46); + assert_or_panic(v[333] == 47); + assert_or_panic(v[334] == 48); + assert_or_panic(v[335] == 49); + assert_or_panic(v[336] == 50); + assert_or_panic(v[337] == 51); + assert_or_panic(v[338] == 52); + assert_or_panic(v[339] == 53); + assert_or_panic(v[340] == 54); + assert_or_panic(v[341] == 55); + assert_or_panic(v[342] == 56); + assert_or_panic(v[343] == 57); + assert_or_panic(v[344] == 58); + assert_or_panic(v[345] == 59); + assert_or_panic(v[346] == 60); + assert_or_panic(v[347] == 61); + assert_or_panic(v[348] == 62); + assert_or_panic(v[349] == 63); + assert_or_panic(v[350] == 64); + assert_or_panic(v[351] == 65); + assert_or_panic(v[352] == 66); + assert_or_panic(v[353] == 67); + assert_or_panic(v[354] == 68); + assert_or_panic(v[355] == 69); + assert_or_panic(v[356] == 70); + assert_or_panic(v[357] == 71); + assert_or_panic(v[358] == 72); + assert_or_panic(v[359] == 73); + assert_or_panic(v[360] == 74); + assert_or_panic(v[361] == 75); + assert_or_panic(v[362] == 76); + assert_or_panic(v[363] == 77); + assert_or_panic(v[364] == 78); + assert_or_panic(v[365] == 79); + assert_or_panic(v[366] == 80); + assert_or_panic(v[367] == 81); + assert_or_panic(v[368] == 82); + assert_or_panic(v[369] == 83); + assert_or_panic(v[370] == 84); + assert_or_panic(v[371] == 85); + assert_or_panic(v[372] == 86); + assert_or_panic(v[373] == 87); + assert_or_panic(v[374] == 88); + assert_or_panic(v[375] == 89); + assert_or_panic(v[376] == 90); + assert_or_panic(v[377] == 91); + assert_or_panic(v[378] == 92); + assert_or_panic(v[379] == 93); + assert_or_panic(v[380] == 94); + assert_or_panic(v[381] == 95); + assert_or_panic(v[382] == 96); + assert_or_panic(v[383] == 97); + assert_or_panic(v[384] == 98); + assert_or_panic(v[385] == 99); + assert_or_panic(v[386] == 0); + assert_or_panic(v[387] == 1); + assert_or_panic(v[388] == 2); + assert_or_panic(v[389] == 3); + assert_or_panic(v[390] == 4); + assert_or_panic(v[391] == 5); + assert_or_panic(v[392] == 6); + assert_or_panic(v[393] == 7); + assert_or_panic(v[394] == 8); + assert_or_panic(v[395] == 9); + assert_or_panic(v[396] == 10); + assert_or_panic(v[397] == 11); + assert_or_panic(v[398] == 12); + assert_or_panic(v[399] == 13); + assert_or_panic(v[400] == 14); + assert_or_panic(v[401] == 15); + assert_or_panic(v[402] == 16); + assert_or_panic(v[403] == 17); + assert_or_panic(v[404] == 18); + assert_or_panic(v[405] == 19); + assert_or_panic(v[406] == 20); + assert_or_panic(v[407] == 21); + assert_or_panic(v[408] == 22); + assert_or_panic(v[409] == 23); + assert_or_panic(v[410] == 24); + assert_or_panic(v[411] == 25); + assert_or_panic(v[412] == 26); + assert_or_panic(v[413] == 27); + assert_or_panic(v[414] == 28); + assert_or_panic(v[415] == 29); + assert_or_panic(v[416] == 30); + assert_or_panic(v[417] == 31); + assert_or_panic(v[418] == 32); + assert_or_panic(v[419] == 33); + assert_or_panic(v[420] == 34); + assert_or_panic(v[421] == 35); + assert_or_panic(v[422] == 36); + assert_or_panic(v[423] == 37); + assert_or_panic(v[424] == 38); + assert_or_panic(v[425] == 39); + assert_or_panic(v[426] == 40); + assert_or_panic(v[427] == 41); + assert_or_panic(v[428] == 42); + assert_or_panic(v[429] == 43); + assert_or_panic(v[430] == 44); + assert_or_panic(v[431] == 45); + assert_or_panic(v[432] == 46); + assert_or_panic(v[433] == 47); + assert_or_panic(v[434] == 48); + assert_or_panic(v[435] == 49); + assert_or_panic(v[436] == 50); + assert_or_panic(v[437] == 51); + assert_or_panic(v[438] == 52); + assert_or_panic(v[439] == 53); + assert_or_panic(v[440] == 54); + assert_or_panic(v[441] == 55); + assert_or_panic(v[442] == 56); + assert_or_panic(v[443] == 57); + assert_or_panic(v[444] == 58); + assert_or_panic(v[445] == 59); + assert_or_panic(v[446] == 60); + assert_or_panic(v[447] == 61); + assert_or_panic(v[448] == 62); + assert_or_panic(v[449] == 63); + assert_or_panic(v[450] == 64); + assert_or_panic(v[451] == 65); + assert_or_panic(v[452] == 66); + assert_or_panic(v[453] == 67); + assert_or_panic(v[454] == 68); + assert_or_panic(v[455] == 69); + assert_or_panic(v[456] == 70); + assert_or_panic(v[457] == 71); + assert_or_panic(v[458] == 72); + assert_or_panic(v[459] == 73); + assert_or_panic(v[460] == 74); + assert_or_panic(v[461] == 75); + assert_or_panic(v[462] == 76); + assert_or_panic(v[463] == 77); + assert_or_panic(v[464] == 78); + assert_or_panic(v[465] == 79); + assert_or_panic(v[466] == 80); + assert_or_panic(v[467] == 81); + assert_or_panic(v[468] == 82); + assert_or_panic(v[469] == 83); + assert_or_panic(v[470] == 84); + assert_or_panic(v[471] == 85); + assert_or_panic(v[472] == 86); + assert_or_panic(v[473] == 87); + assert_or_panic(v[474] == 88); + assert_or_panic(v[475] == 89); + assert_or_panic(v[476] == 90); + assert_or_panic(v[477] == 91); + assert_or_panic(v[478] == 92); + assert_or_panic(v[479] == 93); + assert_or_panic(v[480] == 94); + assert_or_panic(v[481] == 95); + assert_or_panic(v[482] == 96); + assert_or_panic(v[483] == 97); + assert_or_panic(v[484] == 98); + assert_or_panic(v[485] == 99); + assert_or_panic(v[486] == 0); + assert_or_panic(v[487] == 1); + assert_or_panic(v[488] == 2); + assert_or_panic(v[489] == 3); + assert_or_panic(v[490] == 4); + assert_or_panic(v[491] == 5); + assert_or_panic(v[492] == 6); + assert_or_panic(v[493] == 7); + assert_or_panic(v[494] == 8); + assert_or_panic(v[495] == 9); + assert_or_panic(v[496] == 10); + assert_or_panic(v[497] == 11); + assert_or_panic(v[498] == 12); + assert_or_panic(v[499] == 13); + assert_or_panic(v[500] == 14); + assert_or_panic(v[501] == 15); + assert_or_panic(v[502] == 16); + assert_or_panic(v[503] == 17); + assert_or_panic(v[504] == 18); + assert_or_panic(v[505] == 19); + assert_or_panic(v[506] == 20); + assert_or_panic(v[507] == 21); + assert_or_panic(v[508] == 22); + assert_or_panic(v[509] == 23); + assert_or_panic(v[510] == 24); + assert_or_panic(v[511] == 25); + zig_vector_512_u8((Vector_512_u8){ + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + }, 512); +} + +typedef uint16_t Vector_1_u16 __attribute__((vector_size(1 * sizeof(uint16_t)))); + +Vector_1_u16 zig_ret_vector_1_u16(void); +void zig_vector_1_u16(Vector_1_u16, size_t); + +Vector_1_u16 c_ret_vector_1_u16(void) { + return (Vector_1_u16){ 3 }; +} +void c_vector_1_u16(Vector_1_u16 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_u16(void) { + Vector_1_u16 v = zig_ret_vector_1_u16(); + assert_or_panic(v[0] == 1); + zig_vector_1_u16((Vector_1_u16){ 2 }, 1); +} + +typedef uint16_t Vector_2_u16 __attribute__((vector_size(2 * sizeof(uint16_t)))); + +Vector_2_u16 zig_ret_vector_2_u16(void); +void zig_vector_2_u16(Vector_2_u16, size_t); + +Vector_2_u16 c_ret_vector_2_u16(void) { + return (Vector_2_u16){ 9, 10 }; +} +void c_vector_2_u16(Vector_2_u16 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_u16(void) { + Vector_2_u16 v = zig_ret_vector_2_u16(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_u16((Vector_2_u16){ 7, 8 }, 2); +} + +typedef uint16_t Vector_3_u16 __attribute__((vector_size(3 * sizeof(uint16_t)))); + +Vector_3_u16 zig_ret_vector_3_u16(void); +void zig_vector_3_u16(Vector_3_u16, size_t); + +Vector_3_u16 c_ret_vector_3_u16(void) { + return (Vector_3_u16){ 19, 20, 21 }; +} +void c_vector_3_u16(Vector_3_u16 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 3); +} +void c_test_vector_3_u16(void) { + Vector_3_u16 v = zig_ret_vector_3_u16(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_u16((Vector_3_u16){ 16, 17, 18 }, 3); +} + +typedef uint16_t Vector_4_u16 __attribute__((vector_size(4 * sizeof(uint16_t)))); + +Vector_4_u16 zig_ret_vector_4_u16(void); + +void zig_vector_4_u16(Vector_4_u16, size_t); +void zig_vector_4_u16_vector_4_u16(Vector_4_u16, Vector_4_u16, size_t); + +Vector_4_u16 c_ret_vector_4_u16(void) { + return (Vector_4_u16){ 41, 42, 43, 44 }; +} +void c_vector_4_u16(Vector_4_u16 v, size_t i) { + assert_or_panic(v[0] == 45); + assert_or_panic(v[1] == 46); + assert_or_panic(v[2] == 47); + assert_or_panic(v[3] == 48); + assert_or_panic(i == 4); +} +void c_vector_4_u16_vector_4_u16(Vector_4_u16 v0, Vector_4_u16 v1, size_t i) { + assert_or_panic(v0[0] == 49); + assert_or_panic(v0[1] == 50); + assert_or_panic(v0[2] == 51); + assert_or_panic(v0[3] == 52); + assert_or_panic(v1[0] == 53); + assert_or_panic(v1[1] == 54); + assert_or_panic(v1[2] == 55); + assert_or_panic(v1[3] == 56); + assert_or_panic(i == 8); +} +void c_test_vector_4_u16(void) { + Vector_4_u16 v = zig_ret_vector_4_u16(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_u16((Vector_4_u16){ 29, 30, 31, 32 }, 4); + zig_vector_4_u16_vector_4_u16((Vector_4_u16){ 33, 34, 35, 36 }, (Vector_4_u16){ 37, 38, 39, 40 }, 8); +} + +typedef uint16_t Vector_6_u16 __attribute__((vector_size(6 * sizeof(uint16_t)))); + +Vector_6_u16 zig_ret_vector_6_u16(void); +void zig_vector_6_u16(Vector_6_u16, size_t); + +Vector_6_u16 c_ret_vector_6_u16(void) { + return (Vector_6_u16){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_u16(Vector_6_u16 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_u16(void) { + Vector_6_u16 v = zig_ret_vector_6_u16(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_u16((Vector_6_u16){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef uint16_t Vector_8_u16 __attribute__((vector_size(8 * sizeof(uint16_t)))); + +Vector_8_u16 zig_ret_vector_8_u16(void); +void zig_vector_8_u16(Vector_8_u16, size_t); + +Vector_8_u16 c_ret_vector_8_u16(void) { + return (Vector_8_u16){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_u16(Vector_8_u16 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_u16(void) { + Vector_8_u16 v = zig_ret_vector_8_u16(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_u16((Vector_8_u16){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef uint16_t Vector_12_u16 __attribute__((vector_size(12 * sizeof(uint16_t)))); + +Vector_12_u16 zig_ret_vector_12_u16(void); +void zig_vector_12_u16(Vector_12_u16, size_t); + +Vector_12_u16 c_ret_vector_12_u16(void) { + return (Vector_12_u16){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 }; +} +void c_vector_12_u16(Vector_12_u16 v, size_t i) { + assert_or_panic(v[0] == 133); + assert_or_panic(v[1] == 134); + assert_or_panic(v[2] == 135); + assert_or_panic(v[3] == 136); + assert_or_panic(v[4] == 137); + assert_or_panic(v[5] == 138); + assert_or_panic(v[6] == 139); + assert_or_panic(v[7] == 140); + assert_or_panic(v[8] == 141); + assert_or_panic(v[9] == 142); + assert_or_panic(v[10] == 143); + assert_or_panic(v[11] == 144); + assert_or_panic(i == 12); +} +void c_test_vector_12_u16(void) { + Vector_12_u16 v = zig_ret_vector_12_u16(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 100); + assert_or_panic(v[4] == 101); + assert_or_panic(v[5] == 102); + assert_or_panic(v[6] == 103); + assert_or_panic(v[7] == 104); + assert_or_panic(v[8] == 105); + assert_or_panic(v[9] == 106); + assert_or_panic(v[10] == 107); + assert_or_panic(v[11] == 108); + zig_vector_12_u16((Vector_12_u16){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12); +} + +typedef uint16_t Vector_16_u16 __attribute__((vector_size(16 * sizeof(uint16_t)))); + +Vector_16_u16 zig_ret_vector_16_u16(void); +void zig_vector_16_u16(Vector_16_u16, size_t); + +Vector_16_u16 c_ret_vector_16_u16(void) { + return (Vector_16_u16){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 }; +} +void c_vector_16_u16(Vector_16_u16 v, size_t i) { + assert_or_panic(v[0] == 193); + assert_or_panic(v[1] == 194); + assert_or_panic(v[2] == 195); + assert_or_panic(v[3] == 196); + assert_or_panic(v[4] == 197); + assert_or_panic(v[5] == 198); + assert_or_panic(v[6] == 199); + assert_or_panic(v[7] == 200); + assert_or_panic(v[8] == 201); + assert_or_panic(v[9] == 202); + assert_or_panic(v[10] == 203); + assert_or_panic(v[11] == 204); + assert_or_panic(v[12] == 205); + assert_or_panic(v[13] == 206); + assert_or_panic(v[14] == 207); + assert_or_panic(v[15] == 208); + assert_or_panic(i == 16); +} +void c_test_vector_16_u16(void) { + Vector_16_u16 v = zig_ret_vector_16_u16(); + assert_or_panic(v[0] == 145); + assert_or_panic(v[1] == 146); + assert_or_panic(v[2] == 147); + assert_or_panic(v[3] == 148); + assert_or_panic(v[4] == 149); + assert_or_panic(v[5] == 150); + assert_or_panic(v[6] == 151); + assert_or_panic(v[7] == 152); + assert_or_panic(v[8] == 153); + assert_or_panic(v[9] == 154); + assert_or_panic(v[10] == 155); + assert_or_panic(v[11] == 156); + assert_or_panic(v[12] == 157); + assert_or_panic(v[13] == 158); + assert_or_panic(v[14] == 159); + assert_or_panic(v[15] == 160); + zig_vector_16_u16((Vector_16_u16){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16); +} + +typedef uint16_t Vector_24_u16 __attribute__((vector_size(24 * sizeof(uint16_t)))); + +Vector_24_u16 zig_ret_vector_24_u16(void); +void zig_vector_24_u16(Vector_24_u16, size_t); + +Vector_24_u16 c_ret_vector_24_u16(void) { + return (Vector_24_u16){ + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, + }; +} +void c_vector_24_u16(Vector_24_u16 v, size_t i) { + assert_or_panic(v[0] == 281); + assert_or_panic(v[1] == 282); + assert_or_panic(v[2] == 283); + assert_or_panic(v[3] == 284); + assert_or_panic(v[4] == 285); + assert_or_panic(v[5] == 286); + assert_or_panic(v[6] == 287); + assert_or_panic(v[7] == 288); + assert_or_panic(v[8] == 289); + assert_or_panic(v[9] == 290); + assert_or_panic(v[10] == 291); + assert_or_panic(v[11] == 292); + assert_or_panic(v[12] == 293); + assert_or_panic(v[13] == 294); + assert_or_panic(v[14] == 295); + assert_or_panic(v[15] == 296); + assert_or_panic(v[16] == 297); + assert_or_panic(v[17] == 298); + assert_or_panic(v[18] == 299); + assert_or_panic(v[19] == 300); + assert_or_panic(v[20] == 301); + assert_or_panic(v[21] == 302); + assert_or_panic(v[22] == 303); + assert_or_panic(v[23] == 304); + assert_or_panic(i == 24); +} +void c_test_vector_24_u16(void) { + Vector_24_u16 v = zig_ret_vector_24_u16(); + assert_or_panic(v[0] == 209); + assert_or_panic(v[1] == 210); + assert_or_panic(v[2] == 211); + assert_or_panic(v[3] == 212); + assert_or_panic(v[4] == 213); + assert_or_panic(v[5] == 214); + assert_or_panic(v[6] == 215); + assert_or_panic(v[7] == 216); + assert_or_panic(v[8] == 217); + assert_or_panic(v[9] == 218); + assert_or_panic(v[10] == 219); + assert_or_panic(v[11] == 220); + assert_or_panic(v[12] == 221); + assert_or_panic(v[13] == 222); + assert_or_panic(v[14] == 223); + assert_or_panic(v[15] == 224); + assert_or_panic(v[16] == 225); + assert_or_panic(v[17] == 226); + assert_or_panic(v[18] == 227); + assert_or_panic(v[19] == 228); + assert_or_panic(v[20] == 229); + assert_or_panic(v[21] == 230); + assert_or_panic(v[22] == 231); + assert_or_panic(v[23] == 232); + zig_vector_24_u16((Vector_24_u16){ + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, + }, 24); +} + +typedef uint16_t Vector_32_u16 __attribute__((vector_size(32 * sizeof(uint16_t)))); + +Vector_32_u16 zig_ret_vector_32_u16(void); +void zig_vector_32_u16(Vector_32_u16, size_t); + +Vector_32_u16 c_ret_vector_32_u16(void) { + return (Vector_32_u16){ + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + }; +} +void c_vector_32_u16(Vector_32_u16 v, size_t i) { + assert_or_panic(v[0] == 401); + assert_or_panic(v[1] == 402); + assert_or_panic(v[2] == 403); + assert_or_panic(v[3] == 404); + assert_or_panic(v[4] == 405); + assert_or_panic(v[5] == 406); + assert_or_panic(v[6] == 407); + assert_or_panic(v[7] == 408); + assert_or_panic(v[8] == 409); + assert_or_panic(v[9] == 410); + assert_or_panic(v[10] == 411); + assert_or_panic(v[11] == 412); + assert_or_panic(v[12] == 413); + assert_or_panic(v[13] == 414); + assert_or_panic(v[14] == 415); + assert_or_panic(v[15] == 416); + assert_or_panic(v[16] == 417); + assert_or_panic(v[17] == 418); + assert_or_panic(v[18] == 419); + assert_or_panic(v[19] == 420); + assert_or_panic(v[20] == 421); + assert_or_panic(v[21] == 422); + assert_or_panic(v[22] == 423); + assert_or_panic(v[23] == 424); + assert_or_panic(v[24] == 425); + assert_or_panic(v[25] == 426); + assert_or_panic(v[26] == 427); + assert_or_panic(v[27] == 428); + assert_or_panic(v[28] == 429); + assert_or_panic(v[29] == 430); + assert_or_panic(v[30] == 431); + assert_or_panic(v[31] == 432); + assert_or_panic(i == 32); +} +void c_test_vector_32_u16(void) { + Vector_32_u16 v = zig_ret_vector_32_u16(); + assert_or_panic(v[0] == 305); + assert_or_panic(v[1] == 306); + assert_or_panic(v[2] == 307); + assert_or_panic(v[3] == 308); + assert_or_panic(v[4] == 309); + assert_or_panic(v[5] == 310); + assert_or_panic(v[6] == 311); + assert_or_panic(v[7] == 312); + assert_or_panic(v[8] == 313); + assert_or_panic(v[9] == 314); + assert_or_panic(v[10] == 315); + assert_or_panic(v[11] == 316); + assert_or_panic(v[12] == 317); + assert_or_panic(v[13] == 318); + assert_or_panic(v[14] == 319); + assert_or_panic(v[15] == 320); + assert_or_panic(v[16] == 321); + assert_or_panic(v[17] == 322); + assert_or_panic(v[18] == 323); + assert_or_panic(v[19] == 324); + assert_or_panic(v[20] == 325); + assert_or_panic(v[21] == 326); + assert_or_panic(v[22] == 327); + assert_or_panic(v[23] == 328); + assert_or_panic(v[24] == 329); + assert_or_panic(v[25] == 330); + assert_or_panic(v[26] == 331); + assert_or_panic(v[27] == 332); + assert_or_panic(v[28] == 333); + assert_or_panic(v[29] == 334); + assert_or_panic(v[30] == 335); + assert_or_panic(v[31] == 336); + zig_vector_32_u16((Vector_32_u16){ + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + }, 32); +} + +typedef uint16_t Vector_48_u16 __attribute__((vector_size(48 * sizeof(uint16_t)))); + +Vector_48_u16 zig_ret_vector_48_u16(void); +void zig_vector_48_u16(Vector_48_u16, size_t); + +Vector_48_u16 c_ret_vector_48_u16(void) { + return (Vector_48_u16){ + 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, + }; +} +void c_vector_48_u16(Vector_48_u16 v, size_t i) { + assert_or_panic(v[0] == 577); + assert_or_panic(v[1] == 578); + assert_or_panic(v[2] == 579); + assert_or_panic(v[3] == 580); + assert_or_panic(v[4] == 581); + assert_or_panic(v[5] == 582); + assert_or_panic(v[6] == 583); + assert_or_panic(v[7] == 584); + assert_or_panic(v[8] == 585); + assert_or_panic(v[9] == 586); + assert_or_panic(v[10] == 587); + assert_or_panic(v[11] == 588); + assert_or_panic(v[12] == 589); + assert_or_panic(v[13] == 590); + assert_or_panic(v[14] == 591); + assert_or_panic(v[15] == 592); + assert_or_panic(v[16] == 593); + assert_or_panic(v[17] == 594); + assert_or_panic(v[18] == 595); + assert_or_panic(v[19] == 596); + assert_or_panic(v[20] == 597); + assert_or_panic(v[21] == 598); + assert_or_panic(v[22] == 599); + assert_or_panic(v[23] == 600); + assert_or_panic(v[24] == 601); + assert_or_panic(v[25] == 602); + assert_or_panic(v[26] == 603); + assert_or_panic(v[27] == 604); + assert_or_panic(v[28] == 605); + assert_or_panic(v[29] == 606); + assert_or_panic(v[30] == 607); + assert_or_panic(v[31] == 608); + assert_or_panic(v[32] == 609); + assert_or_panic(v[33] == 610); + assert_or_panic(v[34] == 611); + assert_or_panic(v[35] == 612); + assert_or_panic(v[36] == 613); + assert_or_panic(v[37] == 614); + assert_or_panic(v[38] == 615); + assert_or_panic(v[39] == 616); + assert_or_panic(v[40] == 617); + assert_or_panic(v[41] == 618); + assert_or_panic(v[42] == 619); + assert_or_panic(v[43] == 620); + assert_or_panic(v[44] == 621); + assert_or_panic(v[45] == 622); + assert_or_panic(v[46] == 623); + assert_or_panic(v[47] == 624); + assert_or_panic(i == 48); +} +void c_test_vector_48_u16(void) { + Vector_48_u16 v = zig_ret_vector_48_u16(); + assert_or_panic(v[0] == 433); + assert_or_panic(v[1] == 434); + assert_or_panic(v[2] == 435); + assert_or_panic(v[3] == 436); + assert_or_panic(v[4] == 437); + assert_or_panic(v[5] == 438); + assert_or_panic(v[6] == 439); + assert_or_panic(v[7] == 440); + assert_or_panic(v[8] == 441); + assert_or_panic(v[9] == 442); + assert_or_panic(v[10] == 443); + assert_or_panic(v[11] == 444); + assert_or_panic(v[12] == 445); + assert_or_panic(v[13] == 446); + assert_or_panic(v[14] == 447); + assert_or_panic(v[15] == 448); + assert_or_panic(v[16] == 449); + assert_or_panic(v[17] == 450); + assert_or_panic(v[18] == 451); + assert_or_panic(v[19] == 452); + assert_or_panic(v[20] == 453); + assert_or_panic(v[21] == 454); + assert_or_panic(v[22] == 455); + assert_or_panic(v[23] == 456); + assert_or_panic(v[24] == 457); + assert_or_panic(v[25] == 458); + assert_or_panic(v[26] == 459); + assert_or_panic(v[27] == 460); + assert_or_panic(v[28] == 461); + assert_or_panic(v[29] == 462); + assert_or_panic(v[30] == 463); + assert_or_panic(v[31] == 464); + assert_or_panic(v[32] == 465); + assert_or_panic(v[33] == 466); + assert_or_panic(v[34] == 467); + assert_or_panic(v[35] == 468); + assert_or_panic(v[36] == 469); + assert_or_panic(v[37] == 470); + assert_or_panic(v[38] == 471); + assert_or_panic(v[39] == 472); + assert_or_panic(v[40] == 473); + assert_or_panic(v[41] == 474); + assert_or_panic(v[42] == 475); + assert_or_panic(v[43] == 476); + assert_or_panic(v[44] == 477); + assert_or_panic(v[45] == 478); + assert_or_panic(v[46] == 479); + assert_or_panic(v[47] == 480); + zig_vector_48_u16((Vector_48_u16){ + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + }, 48); +} + +typedef uint16_t Vector_64_u16 __attribute__((vector_size(64 * sizeof(uint16_t)))); + +Vector_64_u16 zig_ret_vector_64_u16(void); +void zig_vector_64_u16(Vector_64_u16, size_t); + +Vector_64_u16 c_ret_vector_64_u16(void) { + return (Vector_64_u16){ + 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, + 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, + }; +} +void c_vector_64_u16(Vector_64_u16 v, size_t i) { + assert_or_panic(v[0] == 817); + assert_or_panic(v[1] == 818); + assert_or_panic(v[2] == 819); + assert_or_panic(v[3] == 820); + assert_or_panic(v[4] == 821); + assert_or_panic(v[5] == 822); + assert_or_panic(v[6] == 823); + assert_or_panic(v[7] == 824); + assert_or_panic(v[8] == 825); + assert_or_panic(v[9] == 826); + assert_or_panic(v[10] == 827); + assert_or_panic(v[11] == 828); + assert_or_panic(v[12] == 829); + assert_or_panic(v[13] == 830); + assert_or_panic(v[14] == 831); + assert_or_panic(v[15] == 832); + assert_or_panic(v[16] == 833); + assert_or_panic(v[17] == 834); + assert_or_panic(v[18] == 835); + assert_or_panic(v[19] == 836); + assert_or_panic(v[20] == 837); + assert_or_panic(v[21] == 838); + assert_or_panic(v[22] == 839); + assert_or_panic(v[23] == 840); + assert_or_panic(v[24] == 841); + assert_or_panic(v[25] == 842); + assert_or_panic(v[26] == 843); + assert_or_panic(v[27] == 844); + assert_or_panic(v[28] == 845); + assert_or_panic(v[29] == 846); + assert_or_panic(v[30] == 847); + assert_or_panic(v[31] == 848); + assert_or_panic(v[32] == 849); + assert_or_panic(v[33] == 850); + assert_or_panic(v[34] == 851); + assert_or_panic(v[35] == 852); + assert_or_panic(v[36] == 853); + assert_or_panic(v[37] == 854); + assert_or_panic(v[38] == 855); + assert_or_panic(v[39] == 856); + assert_or_panic(v[40] == 857); + assert_or_panic(v[41] == 858); + assert_or_panic(v[42] == 859); + assert_or_panic(v[43] == 860); + assert_or_panic(v[44] == 861); + assert_or_panic(v[45] == 862); + assert_or_panic(v[46] == 863); + assert_or_panic(v[47] == 864); + assert_or_panic(v[48] == 865); + assert_or_panic(v[49] == 866); + assert_or_panic(v[50] == 867); + assert_or_panic(v[51] == 868); + assert_or_panic(v[52] == 869); + assert_or_panic(v[53] == 870); + assert_or_panic(v[54] == 871); + assert_or_panic(v[55] == 872); + assert_or_panic(v[56] == 873); + assert_or_panic(v[57] == 874); + assert_or_panic(v[58] == 875); + assert_or_panic(v[59] == 876); + assert_or_panic(v[60] == 877); + assert_or_panic(v[61] == 878); + assert_or_panic(v[62] == 879); + assert_or_panic(v[63] == 880); + assert_or_panic(i == 64); +} +void c_test_vector_64_u16(void) { + Vector_64_u16 v = zig_ret_vector_64_u16(); + assert_or_panic(v[0] == 625); + assert_or_panic(v[1] == 626); + assert_or_panic(v[2] == 627); + assert_or_panic(v[3] == 628); + assert_or_panic(v[4] == 629); + assert_or_panic(v[5] == 630); + assert_or_panic(v[6] == 631); + assert_or_panic(v[7] == 632); + assert_or_panic(v[8] == 633); + assert_or_panic(v[9] == 634); + assert_or_panic(v[10] == 635); + assert_or_panic(v[11] == 636); + assert_or_panic(v[12] == 637); + assert_or_panic(v[13] == 638); + assert_or_panic(v[14] == 639); + assert_or_panic(v[15] == 640); + assert_or_panic(v[16] == 641); + assert_or_panic(v[17] == 642); + assert_or_panic(v[18] == 643); + assert_or_panic(v[19] == 644); + assert_or_panic(v[20] == 645); + assert_or_panic(v[21] == 646); + assert_or_panic(v[22] == 647); + assert_or_panic(v[23] == 648); + assert_or_panic(v[24] == 649); + assert_or_panic(v[25] == 650); + assert_or_panic(v[26] == 651); + assert_or_panic(v[27] == 652); + assert_or_panic(v[28] == 653); + assert_or_panic(v[29] == 654); + assert_or_panic(v[30] == 655); + assert_or_panic(v[31] == 656); + assert_or_panic(v[32] == 657); + assert_or_panic(v[33] == 658); + assert_or_panic(v[34] == 659); + assert_or_panic(v[35] == 660); + assert_or_panic(v[36] == 661); + assert_or_panic(v[37] == 662); + assert_or_panic(v[38] == 663); + assert_or_panic(v[39] == 664); + assert_or_panic(v[40] == 665); + assert_or_panic(v[41] == 666); + assert_or_panic(v[42] == 667); + assert_or_panic(v[43] == 668); + assert_or_panic(v[44] == 669); + assert_or_panic(v[45] == 670); + assert_or_panic(v[46] == 671); + assert_or_panic(v[47] == 672); + assert_or_panic(v[48] == 673); + assert_or_panic(v[49] == 674); + assert_or_panic(v[50] == 675); + assert_or_panic(v[51] == 676); + assert_or_panic(v[52] == 677); + assert_or_panic(v[53] == 678); + assert_or_panic(v[54] == 679); + assert_or_panic(v[55] == 680); + assert_or_panic(v[56] == 681); + assert_or_panic(v[57] == 682); + assert_or_panic(v[58] == 683); + assert_or_panic(v[59] == 684); + assert_or_panic(v[60] == 685); + assert_or_panic(v[61] == 686); + assert_or_panic(v[62] == 687); + assert_or_panic(v[63] == 688); + zig_vector_64_u16((Vector_64_u16){ + 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, + 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, + }, 64); +} + +typedef uint16_t Vector_96_u16 __attribute__((vector_size(96 * sizeof(uint16_t)))); + +Vector_96_u16 zig_ret_vector_96_u16(void); +void zig_vector_96_u16(Vector_96_u16, size_t); + +Vector_96_u16 c_ret_vector_96_u16(void) { + return (Vector_96_u16){ + 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, + 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, + 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, + 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, + 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, + 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, + }; +} +void c_vector_96_u16(Vector_96_u16 v, size_t i) { + assert_or_panic(v[0] == 1178); + assert_or_panic(v[1] == 1179); + assert_or_panic(v[2] == 1180); + assert_or_panic(v[3] == 1181); + assert_or_panic(v[4] == 1182); + assert_or_panic(v[5] == 1183); + assert_or_panic(v[6] == 1184); + assert_or_panic(v[7] == 1185); + assert_or_panic(v[8] == 1186); + assert_or_panic(v[9] == 1187); + assert_or_panic(v[10] == 1188); + assert_or_panic(v[11] == 1189); + assert_or_panic(v[12] == 1190); + assert_or_panic(v[13] == 1191); + assert_or_panic(v[14] == 1192); + assert_or_panic(v[15] == 1193); + assert_or_panic(v[16] == 1194); + assert_or_panic(v[17] == 1195); + assert_or_panic(v[18] == 1196); + assert_or_panic(v[19] == 1197); + assert_or_panic(v[20] == 1198); + assert_or_panic(v[21] == 1199); + assert_or_panic(v[22] == 1200); + assert_or_panic(v[23] == 1201); + assert_or_panic(v[24] == 1202); + assert_or_panic(v[25] == 1203); + assert_or_panic(v[26] == 1204); + assert_or_panic(v[27] == 1205); + assert_or_panic(v[28] == 1206); + assert_or_panic(v[29] == 1207); + assert_or_panic(v[30] == 1208); + assert_or_panic(v[31] == 1209); + assert_or_panic(v[32] == 1210); + assert_or_panic(v[33] == 1211); + assert_or_panic(v[34] == 1212); + assert_or_panic(v[35] == 1213); + assert_or_panic(v[36] == 1214); + assert_or_panic(v[37] == 1215); + assert_or_panic(v[38] == 1216); + assert_or_panic(v[39] == 1217); + assert_or_panic(v[40] == 1218); + assert_or_panic(v[41] == 1219); + assert_or_panic(v[42] == 1220); + assert_or_panic(v[43] == 1221); + assert_or_panic(v[44] == 1222); + assert_or_panic(v[45] == 1223); + assert_or_panic(v[46] == 1224); + assert_or_panic(v[47] == 1225); + assert_or_panic(v[48] == 1226); + assert_or_panic(v[49] == 1227); + assert_or_panic(v[50] == 1228); + assert_or_panic(v[51] == 1229); + assert_or_panic(v[52] == 1230); + assert_or_panic(v[53] == 1231); + assert_or_panic(v[54] == 1232); + assert_or_panic(v[55] == 1233); + assert_or_panic(v[56] == 1234); + assert_or_panic(v[57] == 1235); + assert_or_panic(v[58] == 1236); + assert_or_panic(v[59] == 1237); + assert_or_panic(v[60] == 1238); + assert_or_panic(v[61] == 1239); + assert_or_panic(v[62] == 1240); + assert_or_panic(v[63] == 1241); + assert_or_panic(v[64] == 1242); + assert_or_panic(v[65] == 1243); + assert_or_panic(v[66] == 1244); + assert_or_panic(v[67] == 1245); + assert_or_panic(v[68] == 1246); + assert_or_panic(v[69] == 1247); + assert_or_panic(v[70] == 1248); + assert_or_panic(v[71] == 1249); + assert_or_panic(v[72] == 1250); + assert_or_panic(v[73] == 1251); + assert_or_panic(v[74] == 1252); + assert_or_panic(v[75] == 1253); + assert_or_panic(v[76] == 1254); + assert_or_panic(v[77] == 1255); + assert_or_panic(v[80] == 1258); + assert_or_panic(v[81] == 1259); + assert_or_panic(v[82] == 1260); + assert_or_panic(v[83] == 1261); + assert_or_panic(v[84] == 1262); + assert_or_panic(v[85] == 1263); + assert_or_panic(v[86] == 1264); + assert_or_panic(v[87] == 1265); + assert_or_panic(v[88] == 1266); + assert_or_panic(v[89] == 1267); + assert_or_panic(v[90] == 1268); + assert_or_panic(v[91] == 1269); + assert_or_panic(v[92] == 1270); + assert_or_panic(v[93] == 1271); + assert_or_panic(v[94] == 1272); + assert_or_panic(v[95] == 1273); + assert_or_panic(i == 96); +} +void c_test_vector_96_u16(void) { + Vector_96_u16 v = zig_ret_vector_96_u16(); + assert_or_panic(v[0] == 890); + assert_or_panic(v[1] == 891); + assert_or_panic(v[2] == 892); + assert_or_panic(v[3] == 893); + assert_or_panic(v[4] == 894); + assert_or_panic(v[5] == 895); + assert_or_panic(v[6] == 896); + assert_or_panic(v[7] == 897); + assert_or_panic(v[8] == 898); + assert_or_panic(v[9] == 899); + assert_or_panic(v[10] == 900); + assert_or_panic(v[11] == 901); + assert_or_panic(v[12] == 902); + assert_or_panic(v[13] == 903); + assert_or_panic(v[14] == 904); + assert_or_panic(v[15] == 905); + assert_or_panic(v[16] == 906); + assert_or_panic(v[17] == 907); + assert_or_panic(v[18] == 908); + assert_or_panic(v[19] == 909); + assert_or_panic(v[20] == 910); + assert_or_panic(v[21] == 911); + assert_or_panic(v[22] == 912); + assert_or_panic(v[23] == 913); + assert_or_panic(v[24] == 914); + assert_or_panic(v[25] == 915); + assert_or_panic(v[26] == 916); + assert_or_panic(v[27] == 917); + assert_or_panic(v[28] == 918); + assert_or_panic(v[29] == 919); + assert_or_panic(v[30] == 920); + assert_or_panic(v[31] == 921); + assert_or_panic(v[32] == 922); + assert_or_panic(v[33] == 923); + assert_or_panic(v[34] == 924); + assert_or_panic(v[35] == 925); + assert_or_panic(v[36] == 926); + assert_or_panic(v[37] == 927); + assert_or_panic(v[38] == 928); + assert_or_panic(v[39] == 929); + assert_or_panic(v[40] == 930); + assert_or_panic(v[41] == 931); + assert_or_panic(v[42] == 932); + assert_or_panic(v[43] == 933); + assert_or_panic(v[44] == 934); + assert_or_panic(v[45] == 935); + assert_or_panic(v[46] == 936); + assert_or_panic(v[47] == 937); + assert_or_panic(v[48] == 938); + assert_or_panic(v[49] == 939); + assert_or_panic(v[50] == 940); + assert_or_panic(v[51] == 941); + assert_or_panic(v[52] == 942); + assert_or_panic(v[53] == 943); + assert_or_panic(v[54] == 944); + assert_or_panic(v[55] == 945); + assert_or_panic(v[56] == 946); + assert_or_panic(v[57] == 947); + assert_or_panic(v[58] == 948); + assert_or_panic(v[59] == 949); + assert_or_panic(v[60] == 950); + assert_or_panic(v[61] == 951); + assert_or_panic(v[62] == 952); + assert_or_panic(v[63] == 953); + assert_or_panic(v[64] == 954); + assert_or_panic(v[65] == 955); + assert_or_panic(v[66] == 956); + assert_or_panic(v[67] == 957); + assert_or_panic(v[68] == 958); + assert_or_panic(v[69] == 959); + assert_or_panic(v[70] == 960); + assert_or_panic(v[71] == 961); + assert_or_panic(v[72] == 962); + assert_or_panic(v[73] == 963); + assert_or_panic(v[74] == 964); + assert_or_panic(v[75] == 965); + assert_or_panic(v[76] == 966); + assert_or_panic(v[77] == 967); + assert_or_panic(v[78] == 968); + assert_or_panic(v[79] == 969); + assert_or_panic(v[80] == 970); + assert_or_panic(v[81] == 971); + assert_or_panic(v[82] == 972); + assert_or_panic(v[83] == 973); + assert_or_panic(v[84] == 974); + assert_or_panic(v[85] == 975); + assert_or_panic(v[86] == 976); + assert_or_panic(v[87] == 977); + assert_or_panic(v[88] == 978); + assert_or_panic(v[89] == 979); + assert_or_panic(v[90] == 980); + assert_or_panic(v[91] == 981); + assert_or_panic(v[92] == 982); + assert_or_panic(v[93] == 983); + assert_or_panic(v[94] == 984); + assert_or_panic(v[95] == 985); + zig_vector_96_u16((Vector_96_u16){ + 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, + 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, + 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, + 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, + 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, + 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, + }, 96); +} + +typedef uint16_t Vector_128_u16 __attribute__((vector_size(128 * sizeof(uint16_t)))); + +Vector_128_u16 zig_ret_vector_128_u16(void); +void zig_vector_128_u16(Vector_128_u16, size_t); + +Vector_128_u16 c_ret_vector_128_u16(void) { + return (Vector_128_u16){ + 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, + 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, + 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, + 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, + 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, + }; +} +void c_vector_128_u16(Vector_128_u16 v, size_t i) { + assert_or_panic(v[0] == 1658); + assert_or_panic(v[1] == 1659); + assert_or_panic(v[2] == 1660); + assert_or_panic(v[3] == 1661); + assert_or_panic(v[4] == 1662); + assert_or_panic(v[5] == 1663); + assert_or_panic(v[6] == 1664); + assert_or_panic(v[7] == 1665); + assert_or_panic(v[8] == 1666); + assert_or_panic(v[9] == 1667); + assert_or_panic(v[10] == 1668); + assert_or_panic(v[11] == 1669); + assert_or_panic(v[12] == 1670); + assert_or_panic(v[13] == 1671); + assert_or_panic(v[14] == 1672); + assert_or_panic(v[15] == 1673); + assert_or_panic(v[16] == 1674); + assert_or_panic(v[17] == 1675); + assert_or_panic(v[18] == 1676); + assert_or_panic(v[19] == 1677); + assert_or_panic(v[20] == 1678); + assert_or_panic(v[21] == 1679); + assert_or_panic(v[22] == 1680); + assert_or_panic(v[23] == 1681); + assert_or_panic(v[24] == 1682); + assert_or_panic(v[25] == 1683); + assert_or_panic(v[26] == 1684); + assert_or_panic(v[27] == 1685); + assert_or_panic(v[28] == 1686); + assert_or_panic(v[29] == 1687); + assert_or_panic(v[30] == 1688); + assert_or_panic(v[31] == 1689); + assert_or_panic(v[32] == 1690); + assert_or_panic(v[33] == 1691); + assert_or_panic(v[34] == 1692); + assert_or_panic(v[35] == 1693); + assert_or_panic(v[36] == 1694); + assert_or_panic(v[37] == 1695); + assert_or_panic(v[38] == 1696); + assert_or_panic(v[39] == 1697); + assert_or_panic(v[40] == 1698); + assert_or_panic(v[41] == 1699); + assert_or_panic(v[42] == 1700); + assert_or_panic(v[43] == 1701); + assert_or_panic(v[44] == 1702); + assert_or_panic(v[45] == 1703); + assert_or_panic(v[46] == 1704); + assert_or_panic(v[47] == 1705); + assert_or_panic(v[48] == 1706); + assert_or_panic(v[49] == 1707); + assert_or_panic(v[50] == 1708); + assert_or_panic(v[51] == 1709); + assert_or_panic(v[52] == 1710); + assert_or_panic(v[53] == 1711); + assert_or_panic(v[54] == 1712); + assert_or_panic(v[55] == 1713); + assert_or_panic(v[56] == 1714); + assert_or_panic(v[57] == 1715); + assert_or_panic(v[58] == 1716); + assert_or_panic(v[59] == 1717); + assert_or_panic(v[60] == 1718); + assert_or_panic(v[61] == 1719); + assert_or_panic(v[62] == 1720); + assert_or_panic(v[63] == 1721); + assert_or_panic(v[64] == 1722); + assert_or_panic(v[65] == 1723); + assert_or_panic(v[66] == 1724); + assert_or_panic(v[67] == 1725); + assert_or_panic(v[68] == 1726); + assert_or_panic(v[69] == 1727); + assert_or_panic(v[70] == 1728); + assert_or_panic(v[71] == 1729); + assert_or_panic(v[72] == 1730); + assert_or_panic(v[73] == 1731); + assert_or_panic(v[74] == 1732); + assert_or_panic(v[75] == 1733); + assert_or_panic(v[76] == 1734); + assert_or_panic(v[77] == 1735); + assert_or_panic(v[78] == 1736); + assert_or_panic(v[79] == 1737); + assert_or_panic(v[80] == 1738); + assert_or_panic(v[81] == 1739); + assert_or_panic(v[82] == 1740); + assert_or_panic(v[83] == 1741); + assert_or_panic(v[84] == 1742); + assert_or_panic(v[85] == 1743); + assert_or_panic(v[86] == 1744); + assert_or_panic(v[87] == 1745); + assert_or_panic(v[88] == 1746); + assert_or_panic(v[89] == 1747); + assert_or_panic(v[90] == 1748); + assert_or_panic(v[91] == 1749); + assert_or_panic(v[92] == 1750); + assert_or_panic(v[93] == 1751); + assert_or_panic(v[94] == 1752); + assert_or_panic(v[95] == 1753); + assert_or_panic(v[96] == 1754); + assert_or_panic(v[97] == 1755); + assert_or_panic(v[98] == 1756); + assert_or_panic(v[99] == 1757); + assert_or_panic(v[100] == 1758); + assert_or_panic(v[101] == 1759); + assert_or_panic(v[102] == 1760); + assert_or_panic(v[103] == 1761); + assert_or_panic(v[104] == 1762); + assert_or_panic(v[105] == 1763); + assert_or_panic(v[106] == 1764); + assert_or_panic(v[107] == 1765); + assert_or_panic(v[108] == 1766); + assert_or_panic(v[109] == 1767); + assert_or_panic(v[110] == 1768); + assert_or_panic(v[111] == 1769); + assert_or_panic(v[112] == 1770); + assert_or_panic(v[113] == 1771); + assert_or_panic(v[114] == 1772); + assert_or_panic(v[115] == 1773); + assert_or_panic(v[116] == 1774); + assert_or_panic(v[117] == 1775); + assert_or_panic(v[118] == 1776); + assert_or_panic(v[119] == 1777); + assert_or_panic(v[120] == 1778); + assert_or_panic(v[121] == 1779); + assert_or_panic(v[122] == 1780); + assert_or_panic(v[123] == 1781); + assert_or_panic(v[124] == 1782); + assert_or_panic(v[125] == 1783); + assert_or_panic(v[126] == 1784); + assert_or_panic(v[127] == 1785); + assert_or_panic(i == 128); +} +void c_test_vector_128_u16(void) { + Vector_128_u16 v = zig_ret_vector_128_u16(); + assert_or_panic(v[0] == 1274); + assert_or_panic(v[1] == 1275); + assert_or_panic(v[2] == 1276); + assert_or_panic(v[3] == 1277); + assert_or_panic(v[4] == 1278); + assert_or_panic(v[5] == 1279); + assert_or_panic(v[6] == 1280); + assert_or_panic(v[7] == 1281); + assert_or_panic(v[8] == 1282); + assert_or_panic(v[9] == 1283); + assert_or_panic(v[10] == 1284); + assert_or_panic(v[11] == 1285); + assert_or_panic(v[12] == 1286); + assert_or_panic(v[13] == 1287); + assert_or_panic(v[14] == 1288); + assert_or_panic(v[15] == 1289); + assert_or_panic(v[16] == 1290); + assert_or_panic(v[17] == 1291); + assert_or_panic(v[18] == 1292); + assert_or_panic(v[19] == 1293); + assert_or_panic(v[20] == 1294); + assert_or_panic(v[21] == 1295); + assert_or_panic(v[22] == 1296); + assert_or_panic(v[23] == 1297); + assert_or_panic(v[24] == 1298); + assert_or_panic(v[25] == 1299); + assert_or_panic(v[26] == 1300); + assert_or_panic(v[27] == 1301); + assert_or_panic(v[28] == 1302); + assert_or_panic(v[29] == 1303); + assert_or_panic(v[30] == 1304); + assert_or_panic(v[31] == 1305); + assert_or_panic(v[32] == 1306); + assert_or_panic(v[33] == 1307); + assert_or_panic(v[34] == 1308); + assert_or_panic(v[35] == 1309); + assert_or_panic(v[36] == 1310); + assert_or_panic(v[37] == 1311); + assert_or_panic(v[38] == 1312); + assert_or_panic(v[39] == 1313); + assert_or_panic(v[40] == 1314); + assert_or_panic(v[41] == 1315); + assert_or_panic(v[42] == 1316); + assert_or_panic(v[43] == 1317); + assert_or_panic(v[44] == 1318); + assert_or_panic(v[45] == 1319); + assert_or_panic(v[46] == 1320); + assert_or_panic(v[47] == 1321); + assert_or_panic(v[48] == 1322); + assert_or_panic(v[49] == 1323); + assert_or_panic(v[50] == 1324); + assert_or_panic(v[51] == 1325); + assert_or_panic(v[52] == 1326); + assert_or_panic(v[53] == 1327); + assert_or_panic(v[54] == 1328); + assert_or_panic(v[55] == 1329); + assert_or_panic(v[56] == 1330); + assert_or_panic(v[57] == 1331); + assert_or_panic(v[58] == 1332); + assert_or_panic(v[59] == 1333); + assert_or_panic(v[60] == 1334); + assert_or_panic(v[61] == 1335); + assert_or_panic(v[62] == 1336); + assert_or_panic(v[63] == 1337); + assert_or_panic(v[64] == 1338); + assert_or_panic(v[65] == 1339); + assert_or_panic(v[66] == 1340); + assert_or_panic(v[67] == 1341); + assert_or_panic(v[68] == 1342); + assert_or_panic(v[69] == 1343); + assert_or_panic(v[70] == 1344); + assert_or_panic(v[71] == 1345); + assert_or_panic(v[72] == 1346); + assert_or_panic(v[73] == 1347); + assert_or_panic(v[74] == 1348); + assert_or_panic(v[75] == 1349); + assert_or_panic(v[76] == 1350); + assert_or_panic(v[77] == 1351); + assert_or_panic(v[78] == 1352); + assert_or_panic(v[79] == 1353); + assert_or_panic(v[80] == 1354); + assert_or_panic(v[81] == 1355); + assert_or_panic(v[82] == 1356); + assert_or_panic(v[83] == 1357); + assert_or_panic(v[84] == 1358); + assert_or_panic(v[85] == 1359); + assert_or_panic(v[86] == 1360); + assert_or_panic(v[87] == 1361); + assert_or_panic(v[88] == 1362); + assert_or_panic(v[89] == 1363); + assert_or_panic(v[90] == 1364); + assert_or_panic(v[91] == 1365); + assert_or_panic(v[92] == 1366); + assert_or_panic(v[93] == 1367); + assert_or_panic(v[94] == 1368); + assert_or_panic(v[95] == 1369); + assert_or_panic(v[96] == 1370); + assert_or_panic(v[97] == 1371); + assert_or_panic(v[98] == 1372); + assert_or_panic(v[99] == 1373); + assert_or_panic(v[100] == 1374); + assert_or_panic(v[101] == 1375); + assert_or_panic(v[102] == 1376); + assert_or_panic(v[103] == 1377); + assert_or_panic(v[104] == 1378); + assert_or_panic(v[105] == 1379); + assert_or_panic(v[106] == 1380); + assert_or_panic(v[107] == 1381); + assert_or_panic(v[108] == 1382); + assert_or_panic(v[109] == 1383); + assert_or_panic(v[110] == 1384); + assert_or_panic(v[111] == 1385); + assert_or_panic(v[112] == 1386); + assert_or_panic(v[113] == 1387); + assert_or_panic(v[114] == 1388); + assert_or_panic(v[115] == 1389); + assert_or_panic(v[116] == 1390); + assert_or_panic(v[117] == 1391); + assert_or_panic(v[118] == 1392); + assert_or_panic(v[119] == 1393); + assert_or_panic(v[120] == 1394); + assert_or_panic(v[121] == 1395); + assert_or_panic(v[122] == 1396); + assert_or_panic(v[123] == 1397); + assert_or_panic(v[124] == 1398); + assert_or_panic(v[125] == 1399); + assert_or_panic(v[126] == 1400); + assert_or_panic(v[127] == 1401); + zig_vector_128_u16((Vector_128_u16){ + 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, + 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, + 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, + 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, + 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, + 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, + 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, + 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, + }, 128); +} + +typedef uint16_t Vector_192_u16 __attribute__((vector_size(192 * sizeof(uint16_t)))); + +Vector_192_u16 zig_ret_vector_192_u16(void); +void zig_vector_192_u16(Vector_192_u16, size_t); + +Vector_192_u16 c_ret_vector_192_u16(void) { + return (Vector_192_u16){ + 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, + 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, + 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, + 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, + 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, + 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, + 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, + 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, + 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, + 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, + 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, + 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361, + }; +} +void c_vector_192_u16(Vector_192_u16 v, size_t i) { + assert_or_panic(v[0] == 2362); + assert_or_panic(v[1] == 2363); + assert_or_panic(v[2] == 2364); + assert_or_panic(v[3] == 2365); + assert_or_panic(v[4] == 2366); + assert_or_panic(v[5] == 2367); + assert_or_panic(v[6] == 2368); + assert_or_panic(v[7] == 2369); + assert_or_panic(v[8] == 2370); + assert_or_panic(v[9] == 2371); + assert_or_panic(v[10] == 2372); + assert_or_panic(v[11] == 2373); + assert_or_panic(v[12] == 2374); + assert_or_panic(v[13] == 2375); + assert_or_panic(v[14] == 2376); + assert_or_panic(v[15] == 2377); + assert_or_panic(v[16] == 2378); + assert_or_panic(v[17] == 2379); + assert_or_panic(v[18] == 2380); + assert_or_panic(v[19] == 2381); + assert_or_panic(v[20] == 2382); + assert_or_panic(v[21] == 2383); + assert_or_panic(v[22] == 2384); + assert_or_panic(v[23] == 2385); + assert_or_panic(v[24] == 2386); + assert_or_panic(v[25] == 2387); + assert_or_panic(v[26] == 2388); + assert_or_panic(v[27] == 2389); + assert_or_panic(v[28] == 2390); + assert_or_panic(v[29] == 2391); + assert_or_panic(v[30] == 2392); + assert_or_panic(v[31] == 2393); + assert_or_panic(v[32] == 2394); + assert_or_panic(v[33] == 2395); + assert_or_panic(v[34] == 2396); + assert_or_panic(v[35] == 2397); + assert_or_panic(v[36] == 2398); + assert_or_panic(v[37] == 2399); + assert_or_panic(v[38] == 2400); + assert_or_panic(v[39] == 2401); + assert_or_panic(v[40] == 2402); + assert_or_panic(v[41] == 2403); + assert_or_panic(v[42] == 2404); + assert_or_panic(v[43] == 2405); + assert_or_panic(v[44] == 2406); + assert_or_panic(v[45] == 2407); + assert_or_panic(v[46] == 2408); + assert_or_panic(v[47] == 2409); + assert_or_panic(v[48] == 2410); + assert_or_panic(v[49] == 2411); + assert_or_panic(v[50] == 2412); + assert_or_panic(v[51] == 2413); + assert_or_panic(v[52] == 2414); + assert_or_panic(v[53] == 2415); + assert_or_panic(v[54] == 2416); + assert_or_panic(v[55] == 2417); + assert_or_panic(v[56] == 2418); + assert_or_panic(v[57] == 2419); + assert_or_panic(v[58] == 2420); + assert_or_panic(v[59] == 2421); + assert_or_panic(v[60] == 2422); + assert_or_panic(v[61] == 2423); + assert_or_panic(v[62] == 2424); + assert_or_panic(v[63] == 2425); + assert_or_panic(v[64] == 2426); + assert_or_panic(v[65] == 2427); + assert_or_panic(v[66] == 2428); + assert_or_panic(v[67] == 2429); + assert_or_panic(v[68] == 2430); + assert_or_panic(v[69] == 2431); + assert_or_panic(v[70] == 2432); + assert_or_panic(v[71] == 2433); + assert_or_panic(v[72] == 2434); + assert_or_panic(v[73] == 2435); + assert_or_panic(v[74] == 2436); + assert_or_panic(v[75] == 2437); + assert_or_panic(v[76] == 2438); + assert_or_panic(v[77] == 2439); + assert_or_panic(v[78] == 2440); + assert_or_panic(v[79] == 2441); + assert_or_panic(v[80] == 2442); + assert_or_panic(v[81] == 2443); + assert_or_panic(v[82] == 2444); + assert_or_panic(v[83] == 2445); + assert_or_panic(v[84] == 2446); + assert_or_panic(v[85] == 2447); + assert_or_panic(v[86] == 2448); + assert_or_panic(v[87] == 2449); + assert_or_panic(v[88] == 2450); + assert_or_panic(v[89] == 2451); + assert_or_panic(v[90] == 2452); + assert_or_panic(v[91] == 2453); + assert_or_panic(v[92] == 2454); + assert_or_panic(v[93] == 2455); + assert_or_panic(v[94] == 2456); + assert_or_panic(v[95] == 2457); + assert_or_panic(v[96] == 2458); + assert_or_panic(v[97] == 2459); + assert_or_panic(v[98] == 2460); + assert_or_panic(v[99] == 2461); + assert_or_panic(v[100] == 2462); + assert_or_panic(v[101] == 2463); + assert_or_panic(v[102] == 2464); + assert_or_panic(v[103] == 2465); + assert_or_panic(v[104] == 2466); + assert_or_panic(v[105] == 2467); + assert_or_panic(v[106] == 2468); + assert_or_panic(v[107] == 2469); + assert_or_panic(v[108] == 2470); + assert_or_panic(v[109] == 2471); + assert_or_panic(v[110] == 2472); + assert_or_panic(v[111] == 2473); + assert_or_panic(v[112] == 2474); + assert_or_panic(v[113] == 2475); + assert_or_panic(v[114] == 2476); + assert_or_panic(v[115] == 2477); + assert_or_panic(v[116] == 2478); + assert_or_panic(v[117] == 2479); + assert_or_panic(v[118] == 2480); + assert_or_panic(v[119] == 2481); + assert_or_panic(v[120] == 2482); + assert_or_panic(v[121] == 2483); + assert_or_panic(v[122] == 2484); + assert_or_panic(v[123] == 2485); + assert_or_panic(v[124] == 2486); + assert_or_panic(v[125] == 2487); + assert_or_panic(v[126] == 2488); + assert_or_panic(v[127] == 2489); + assert_or_panic(v[128] == 2490); + assert_or_panic(v[129] == 2491); + assert_or_panic(v[130] == 2492); + assert_or_panic(v[131] == 2493); + assert_or_panic(v[132] == 2494); + assert_or_panic(v[133] == 2495); + assert_or_panic(v[134] == 2496); + assert_or_panic(v[135] == 2497); + assert_or_panic(v[136] == 2498); + assert_or_panic(v[137] == 2499); + assert_or_panic(v[138] == 2500); + assert_or_panic(v[139] == 2501); + assert_or_panic(v[140] == 2502); + assert_or_panic(v[141] == 2503); + assert_or_panic(v[142] == 2504); + assert_or_panic(v[143] == 2505); + assert_or_panic(v[144] == 2506); + assert_or_panic(v[145] == 2507); + assert_or_panic(v[146] == 2508); + assert_or_panic(v[147] == 2509); + assert_or_panic(v[148] == 2510); + assert_or_panic(v[149] == 2511); + assert_or_panic(v[150] == 2512); + assert_or_panic(v[151] == 2513); + assert_or_panic(v[152] == 2514); + assert_or_panic(v[153] == 2515); + assert_or_panic(v[154] == 2516); + assert_or_panic(v[155] == 2517); + assert_or_panic(v[156] == 2518); + assert_or_panic(v[157] == 2519); + assert_or_panic(v[158] == 2520); + assert_or_panic(v[159] == 2521); + assert_or_panic(v[160] == 2522); + assert_or_panic(v[161] == 2523); + assert_or_panic(v[162] == 2524); + assert_or_panic(v[163] == 2525); + assert_or_panic(v[164] == 2526); + assert_or_panic(v[165] == 2527); + assert_or_panic(v[166] == 2528); + assert_or_panic(v[167] == 2529); + assert_or_panic(v[168] == 2530); + assert_or_panic(v[169] == 2531); + assert_or_panic(v[170] == 2532); + assert_or_panic(v[171] == 2533); + assert_or_panic(v[172] == 2534); + assert_or_panic(v[173] == 2535); + assert_or_panic(v[174] == 2536); + assert_or_panic(v[175] == 2537); + assert_or_panic(v[176] == 2538); + assert_or_panic(v[177] == 2539); + assert_or_panic(v[178] == 2540); + assert_or_panic(v[179] == 2541); + assert_or_panic(v[180] == 2542); + assert_or_panic(v[181] == 2543); + assert_or_panic(v[182] == 2544); + assert_or_panic(v[183] == 2545); + assert_or_panic(v[184] == 2546); + assert_or_panic(v[185] == 2547); + assert_or_panic(v[186] == 2548); + assert_or_panic(v[187] == 2549); + assert_or_panic(v[188] == 2550); + assert_or_panic(v[189] == 2551); + assert_or_panic(v[190] == 2552); + assert_or_panic(v[191] == 2553); + assert_or_panic(i == 192); +} +void c_test_vector_192_u16(void) { + Vector_192_u16 v = zig_ret_vector_192_u16(); + assert_or_panic(v[0] == 1786); + assert_or_panic(v[1] == 1787); + assert_or_panic(v[2] == 1788); + assert_or_panic(v[3] == 1789); + assert_or_panic(v[4] == 1790); + assert_or_panic(v[5] == 1791); + assert_or_panic(v[6] == 1792); + assert_or_panic(v[7] == 1793); + assert_or_panic(v[8] == 1794); + assert_or_panic(v[9] == 1795); + assert_or_panic(v[10] == 1796); + assert_or_panic(v[11] == 1797); + assert_or_panic(v[12] == 1798); + assert_or_panic(v[13] == 1799); + assert_or_panic(v[14] == 1800); + assert_or_panic(v[15] == 1801); + assert_or_panic(v[16] == 1802); + assert_or_panic(v[17] == 1803); + assert_or_panic(v[18] == 1804); + assert_or_panic(v[19] == 1805); + assert_or_panic(v[20] == 1806); + assert_or_panic(v[21] == 1807); + assert_or_panic(v[22] == 1808); + assert_or_panic(v[23] == 1809); + assert_or_panic(v[24] == 1810); + assert_or_panic(v[25] == 1811); + assert_or_panic(v[26] == 1812); + assert_or_panic(v[27] == 1813); + assert_or_panic(v[28] == 1814); + assert_or_panic(v[29] == 1815); + assert_or_panic(v[30] == 1816); + assert_or_panic(v[31] == 1817); + assert_or_panic(v[32] == 1818); + assert_or_panic(v[33] == 1819); + assert_or_panic(v[34] == 1820); + assert_or_panic(v[35] == 1821); + assert_or_panic(v[36] == 1822); + assert_or_panic(v[37] == 1823); + assert_or_panic(v[38] == 1824); + assert_or_panic(v[39] == 1825); + assert_or_panic(v[40] == 1826); + assert_or_panic(v[41] == 1827); + assert_or_panic(v[42] == 1828); + assert_or_panic(v[43] == 1829); + assert_or_panic(v[44] == 1830); + assert_or_panic(v[45] == 1831); + assert_or_panic(v[46] == 1832); + assert_or_panic(v[47] == 1833); + assert_or_panic(v[48] == 1834); + assert_or_panic(v[49] == 1835); + assert_or_panic(v[50] == 1836); + assert_or_panic(v[51] == 1837); + assert_or_panic(v[52] == 1838); + assert_or_panic(v[53] == 1839); + assert_or_panic(v[54] == 1840); + assert_or_panic(v[55] == 1841); + assert_or_panic(v[56] == 1842); + assert_or_panic(v[57] == 1843); + assert_or_panic(v[58] == 1844); + assert_or_panic(v[59] == 1845); + assert_or_panic(v[60] == 1846); + assert_or_panic(v[61] == 1847); + assert_or_panic(v[62] == 1848); + assert_or_panic(v[63] == 1849); + assert_or_panic(v[64] == 1850); + assert_or_panic(v[65] == 1851); + assert_or_panic(v[66] == 1852); + assert_or_panic(v[67] == 1853); + assert_or_panic(v[68] == 1854); + assert_or_panic(v[69] == 1855); + assert_or_panic(v[70] == 1856); + assert_or_panic(v[71] == 1857); + assert_or_panic(v[72] == 1858); + assert_or_panic(v[73] == 1859); + assert_or_panic(v[74] == 1860); + assert_or_panic(v[75] == 1861); + assert_or_panic(v[76] == 1862); + assert_or_panic(v[77] == 1863); + assert_or_panic(v[78] == 1864); + assert_or_panic(v[79] == 1865); + assert_or_panic(v[80] == 1866); + assert_or_panic(v[81] == 1867); + assert_or_panic(v[82] == 1868); + assert_or_panic(v[83] == 1869); + assert_or_panic(v[84] == 1870); + assert_or_panic(v[85] == 1871); + assert_or_panic(v[86] == 1872); + assert_or_panic(v[87] == 1873); + assert_or_panic(v[88] == 1874); + assert_or_panic(v[89] == 1875); + assert_or_panic(v[90] == 1876); + assert_or_panic(v[91] == 1877); + assert_or_panic(v[92] == 1878); + assert_or_panic(v[93] == 1879); + assert_or_panic(v[94] == 1880); + assert_or_panic(v[95] == 1881); + assert_or_panic(v[96] == 1882); + assert_or_panic(v[97] == 1883); + assert_or_panic(v[98] == 1884); + assert_or_panic(v[99] == 1885); + assert_or_panic(v[100] == 1886); + assert_or_panic(v[101] == 1887); + assert_or_panic(v[102] == 1888); + assert_or_panic(v[103] == 1889); + assert_or_panic(v[104] == 1890); + assert_or_panic(v[105] == 1891); + assert_or_panic(v[106] == 1892); + assert_or_panic(v[107] == 1893); + assert_or_panic(v[108] == 1894); + assert_or_panic(v[109] == 1895); + assert_or_panic(v[110] == 1896); + assert_or_panic(v[111] == 1897); + assert_or_panic(v[112] == 1898); + assert_or_panic(v[113] == 1899); + assert_or_panic(v[114] == 1900); + assert_or_panic(v[115] == 1901); + assert_or_panic(v[116] == 1902); + assert_or_panic(v[117] == 1903); + assert_or_panic(v[118] == 1904); + assert_or_panic(v[119] == 1905); + assert_or_panic(v[120] == 1906); + assert_or_panic(v[121] == 1907); + assert_or_panic(v[122] == 1908); + assert_or_panic(v[123] == 1909); + assert_or_panic(v[124] == 1910); + assert_or_panic(v[125] == 1911); + assert_or_panic(v[126] == 1912); + assert_or_panic(v[127] == 1913); + assert_or_panic(v[128] == 1914); + assert_or_panic(v[129] == 1915); + assert_or_panic(v[130] == 1916); + assert_or_panic(v[131] == 1917); + assert_or_panic(v[132] == 1918); + assert_or_panic(v[133] == 1919); + assert_or_panic(v[134] == 1920); + assert_or_panic(v[135] == 1921); + assert_or_panic(v[136] == 1922); + assert_or_panic(v[137] == 1923); + assert_or_panic(v[138] == 1924); + assert_or_panic(v[139] == 1925); + assert_or_panic(v[140] == 1926); + assert_or_panic(v[141] == 1927); + assert_or_panic(v[142] == 1928); + assert_or_panic(v[143] == 1929); + assert_or_panic(v[144] == 1930); + assert_or_panic(v[145] == 1931); + assert_or_panic(v[146] == 1932); + assert_or_panic(v[147] == 1933); + assert_or_panic(v[148] == 1934); + assert_or_panic(v[149] == 1935); + assert_or_panic(v[150] == 1936); + assert_or_panic(v[151] == 1937); + assert_or_panic(v[152] == 1938); + assert_or_panic(v[153] == 1939); + assert_or_panic(v[154] == 1940); + assert_or_panic(v[155] == 1941); + assert_or_panic(v[156] == 1942); + assert_or_panic(v[157] == 1943); + assert_or_panic(v[158] == 1944); + assert_or_panic(v[159] == 1945); + assert_or_panic(v[160] == 1946); + assert_or_panic(v[161] == 1947); + assert_or_panic(v[162] == 1948); + assert_or_panic(v[163] == 1949); + assert_or_panic(v[164] == 1950); + assert_or_panic(v[165] == 1951); + assert_or_panic(v[166] == 1952); + assert_or_panic(v[167] == 1953); + assert_or_panic(v[168] == 1954); + assert_or_panic(v[169] == 1955); + assert_or_panic(v[170] == 1956); + assert_or_panic(v[171] == 1957); + assert_or_panic(v[172] == 1958); + assert_or_panic(v[173] == 1959); + assert_or_panic(v[174] == 1960); + assert_or_panic(v[175] == 1961); + assert_or_panic(v[176] == 1962); + assert_or_panic(v[177] == 1963); + assert_or_panic(v[178] == 1964); + assert_or_panic(v[179] == 1965); + assert_or_panic(v[180] == 1966); + assert_or_panic(v[181] == 1967); + assert_or_panic(v[182] == 1968); + assert_or_panic(v[183] == 1969); + assert_or_panic(v[184] == 1970); + assert_or_panic(v[185] == 1971); + assert_or_panic(v[186] == 1972); + assert_or_panic(v[187] == 1973); + assert_or_panic(v[188] == 1974); + assert_or_panic(v[189] == 1975); + assert_or_panic(v[190] == 1976); + assert_or_panic(v[191] == 1977); + zig_vector_192_u16((Vector_192_u16){ + 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, + 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, + 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, + 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, + 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, + 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, + 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089, + 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, + 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, + 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, + 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153, + 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, + }, 192); +} + +typedef uint16_t Vector_256_u16 __attribute__((vector_size(256 * sizeof(uint16_t)))); + +Vector_256_u16 zig_ret_vector_256_u16(void); +void zig_vector_256_u16(Vector_256_u16, size_t); + +Vector_256_u16 c_ret_vector_256_u16(void) { + return (Vector_256_u16){ + 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081, + 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097, + 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113, + 3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, + 3130, 3131, 3132, 3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145, + 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161, + 3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177, + 3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 3193, + 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209, + 3210, 3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, + 3226, 3227, 3228, 3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241, + 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257, + 3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273, + 3274, 3275, 3276, 3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288, 3289, + 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302, 3303, 3304, 3305, + 3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321, + }; +} +void c_vector_256_u16(Vector_256_u16 v, size_t i) { + assert_or_panic(v[0] == 3322); + assert_or_panic(v[1] == 3323); + assert_or_panic(v[2] == 3324); + assert_or_panic(v[3] == 3325); + assert_or_panic(v[4] == 3326); + assert_or_panic(v[5] == 3327); + assert_or_panic(v[6] == 3328); + assert_or_panic(v[7] == 3329); + assert_or_panic(v[8] == 3330); + assert_or_panic(v[9] == 3331); + assert_or_panic(v[10] == 3332); + assert_or_panic(v[11] == 3333); + assert_or_panic(v[12] == 3334); + assert_or_panic(v[13] == 3335); + assert_or_panic(v[14] == 3336); + assert_or_panic(v[15] == 3337); + assert_or_panic(v[16] == 3338); + assert_or_panic(v[17] == 3339); + assert_or_panic(v[18] == 3340); + assert_or_panic(v[19] == 3341); + assert_or_panic(v[20] == 3342); + assert_or_panic(v[21] == 3343); + assert_or_panic(v[22] == 3344); + assert_or_panic(v[23] == 3345); + assert_or_panic(v[24] == 3346); + assert_or_panic(v[25] == 3347); + assert_or_panic(v[26] == 3348); + assert_or_panic(v[27] == 3349); + assert_or_panic(v[28] == 3350); + assert_or_panic(v[29] == 3351); + assert_or_panic(v[30] == 3352); + assert_or_panic(v[31] == 3353); + assert_or_panic(v[32] == 3354); + assert_or_panic(v[33] == 3355); + assert_or_panic(v[34] == 3356); + assert_or_panic(v[35] == 3357); + assert_or_panic(v[36] == 3358); + assert_or_panic(v[37] == 3359); + assert_or_panic(v[38] == 3360); + assert_or_panic(v[39] == 3361); + assert_or_panic(v[40] == 3362); + assert_or_panic(v[41] == 3363); + assert_or_panic(v[42] == 3364); + assert_or_panic(v[43] == 3365); + assert_or_panic(v[44] == 3366); + assert_or_panic(v[45] == 3367); + assert_or_panic(v[46] == 3368); + assert_or_panic(v[47] == 3369); + assert_or_panic(v[48] == 3370); + assert_or_panic(v[49] == 3371); + assert_or_panic(v[50] == 3372); + assert_or_panic(v[51] == 3373); + assert_or_panic(v[52] == 3374); + assert_or_panic(v[53] == 3375); + assert_or_panic(v[54] == 3376); + assert_or_panic(v[55] == 3377); + assert_or_panic(v[56] == 3378); + assert_or_panic(v[57] == 3379); + assert_or_panic(v[58] == 3380); + assert_or_panic(v[59] == 3381); + assert_or_panic(v[60] == 3382); + assert_or_panic(v[61] == 3383); + assert_or_panic(v[62] == 3384); + assert_or_panic(v[63] == 3385); + assert_or_panic(v[64] == 3386); + assert_or_panic(v[65] == 3387); + assert_or_panic(v[66] == 3388); + assert_or_panic(v[67] == 3389); + assert_or_panic(v[68] == 3390); + assert_or_panic(v[69] == 3391); + assert_or_panic(v[70] == 3392); + assert_or_panic(v[71] == 3393); + assert_or_panic(v[72] == 3394); + assert_or_panic(v[73] == 3395); + assert_or_panic(v[74] == 3396); + assert_or_panic(v[75] == 3397); + assert_or_panic(v[76] == 3398); + assert_or_panic(v[77] == 3399); + assert_or_panic(v[78] == 3400); + assert_or_panic(v[79] == 3401); + assert_or_panic(v[80] == 3402); + assert_or_panic(v[81] == 3403); + assert_or_panic(v[82] == 3404); + assert_or_panic(v[83] == 3405); + assert_or_panic(v[84] == 3406); + assert_or_panic(v[85] == 3407); + assert_or_panic(v[86] == 3408); + assert_or_panic(v[87] == 3409); + assert_or_panic(v[88] == 3410); + assert_or_panic(v[89] == 3411); + assert_or_panic(v[90] == 3412); + assert_or_panic(v[91] == 3413); + assert_or_panic(v[92] == 3414); + assert_or_panic(v[93] == 3415); + assert_or_panic(v[94] == 3416); + assert_or_panic(v[95] == 3417); + assert_or_panic(v[96] == 3418); + assert_or_panic(v[97] == 3419); + assert_or_panic(v[98] == 3420); + assert_or_panic(v[99] == 3421); + assert_or_panic(v[100] == 3422); + assert_or_panic(v[101] == 3423); + assert_or_panic(v[102] == 3424); + assert_or_panic(v[103] == 3425); + assert_or_panic(v[104] == 3426); + assert_or_panic(v[105] == 3427); + assert_or_panic(v[106] == 3428); + assert_or_panic(v[107] == 3429); + assert_or_panic(v[108] == 3430); + assert_or_panic(v[109] == 3431); + assert_or_panic(v[110] == 3432); + assert_or_panic(v[111] == 3433); + assert_or_panic(v[112] == 3434); + assert_or_panic(v[113] == 3435); + assert_or_panic(v[114] == 3436); + assert_or_panic(v[115] == 3437); + assert_or_panic(v[116] == 3438); + assert_or_panic(v[117] == 3439); + assert_or_panic(v[118] == 3440); + assert_or_panic(v[119] == 3441); + assert_or_panic(v[120] == 3442); + assert_or_panic(v[121] == 3443); + assert_or_panic(v[122] == 3444); + assert_or_panic(v[123] == 3445); + assert_or_panic(v[124] == 3446); + assert_or_panic(v[125] == 3447); + assert_or_panic(v[126] == 3448); + assert_or_panic(v[127] == 3449); + assert_or_panic(v[128] == 3450); + assert_or_panic(v[129] == 3451); + assert_or_panic(v[130] == 3452); + assert_or_panic(v[131] == 3453); + assert_or_panic(v[132] == 3454); + assert_or_panic(v[133] == 3455); + assert_or_panic(v[134] == 3456); + assert_or_panic(v[135] == 3457); + assert_or_panic(v[136] == 3458); + assert_or_panic(v[137] == 3459); + assert_or_panic(v[138] == 3460); + assert_or_panic(v[139] == 3461); + assert_or_panic(v[140] == 3462); + assert_or_panic(v[141] == 3463); + assert_or_panic(v[142] == 3464); + assert_or_panic(v[143] == 3465); + assert_or_panic(v[144] == 3466); + assert_or_panic(v[145] == 3467); + assert_or_panic(v[146] == 3468); + assert_or_panic(v[147] == 3469); + assert_or_panic(v[148] == 3470); + assert_or_panic(v[149] == 3471); + assert_or_panic(v[150] == 3472); + assert_or_panic(v[151] == 3473); + assert_or_panic(v[152] == 3474); + assert_or_panic(v[153] == 3475); + assert_or_panic(v[154] == 3476); + assert_or_panic(v[155] == 3477); + assert_or_panic(v[156] == 3478); + assert_or_panic(v[157] == 3479); + assert_or_panic(v[158] == 3480); + assert_or_panic(v[159] == 3481); + assert_or_panic(v[160] == 3482); + assert_or_panic(v[161] == 3483); + assert_or_panic(v[162] == 3484); + assert_or_panic(v[163] == 3485); + assert_or_panic(v[164] == 3486); + assert_or_panic(v[165] == 3487); + assert_or_panic(v[166] == 3488); + assert_or_panic(v[167] == 3489); + assert_or_panic(v[168] == 3490); + assert_or_panic(v[169] == 3491); + assert_or_panic(v[170] == 3492); + assert_or_panic(v[171] == 3493); + assert_or_panic(v[172] == 3494); + assert_or_panic(v[173] == 3495); + assert_or_panic(v[174] == 3496); + assert_or_panic(v[175] == 3497); + assert_or_panic(v[176] == 3498); + assert_or_panic(v[177] == 3499); + assert_or_panic(v[178] == 3500); + assert_or_panic(v[179] == 3501); + assert_or_panic(v[180] == 3502); + assert_or_panic(v[181] == 3503); + assert_or_panic(v[182] == 3504); + assert_or_panic(v[183] == 3505); + assert_or_panic(v[184] == 3506); + assert_or_panic(v[185] == 3507); + assert_or_panic(v[186] == 3508); + assert_or_panic(v[187] == 3509); + assert_or_panic(v[188] == 3510); + assert_or_panic(v[189] == 3511); + assert_or_panic(v[190] == 3512); + assert_or_panic(v[191] == 3513); + assert_or_panic(v[192] == 3514); + assert_or_panic(v[193] == 3515); + assert_or_panic(v[194] == 3516); + assert_or_panic(v[195] == 3517); + assert_or_panic(v[196] == 3518); + assert_or_panic(v[197] == 3519); + assert_or_panic(v[198] == 3520); + assert_or_panic(v[199] == 3521); + assert_or_panic(v[200] == 3522); + assert_or_panic(v[201] == 3523); + assert_or_panic(v[202] == 3524); + assert_or_panic(v[203] == 3525); + assert_or_panic(v[204] == 3526); + assert_or_panic(v[205] == 3527); + assert_or_panic(v[206] == 3528); + assert_or_panic(v[207] == 3529); + assert_or_panic(v[208] == 3530); + assert_or_panic(v[209] == 3531); + assert_or_panic(v[210] == 3532); + assert_or_panic(v[211] == 3533); + assert_or_panic(v[212] == 3534); + assert_or_panic(v[213] == 3535); + assert_or_panic(v[214] == 3536); + assert_or_panic(v[215] == 3537); + assert_or_panic(v[216] == 3538); + assert_or_panic(v[217] == 3539); + assert_or_panic(v[218] == 3540); + assert_or_panic(v[219] == 3541); + assert_or_panic(v[220] == 3542); + assert_or_panic(v[221] == 3543); + assert_or_panic(v[222] == 3544); + assert_or_panic(v[223] == 3545); + assert_or_panic(v[224] == 3546); + assert_or_panic(v[225] == 3547); + assert_or_panic(v[226] == 3548); + assert_or_panic(v[227] == 3549); + assert_or_panic(v[228] == 3550); + assert_or_panic(v[229] == 3551); + assert_or_panic(v[230] == 3552); + assert_or_panic(v[231] == 3553); + assert_or_panic(v[232] == 3554); + assert_or_panic(v[233] == 3555); + assert_or_panic(v[234] == 3556); + assert_or_panic(v[235] == 3557); + assert_or_panic(v[236] == 3558); + assert_or_panic(v[237] == 3559); + assert_or_panic(v[238] == 3560); + assert_or_panic(v[239] == 3561); + assert_or_panic(v[240] == 3562); + assert_or_panic(v[241] == 3563); + assert_or_panic(v[242] == 3564); + assert_or_panic(v[243] == 3565); + assert_or_panic(v[244] == 3566); + assert_or_panic(v[245] == 3567); + assert_or_panic(v[246] == 3568); + assert_or_panic(v[247] == 3569); + assert_or_panic(v[248] == 3570); + assert_or_panic(v[249] == 3571); + assert_or_panic(v[250] == 3572); + assert_or_panic(v[251] == 3573); + assert_or_panic(v[252] == 3574); + assert_or_panic(v[253] == 3575); + assert_or_panic(v[254] == 3576); + assert_or_panic(v[255] == 3577); + assert_or_panic(i == 256); +} +void c_test_vector_256_u16(void) { + Vector_256_u16 v = zig_ret_vector_256_u16(); + assert_or_panic(v[0] == 2554); + assert_or_panic(v[1] == 2555); + assert_or_panic(v[2] == 2556); + assert_or_panic(v[3] == 2557); + assert_or_panic(v[4] == 2558); + assert_or_panic(v[5] == 2559); + assert_or_panic(v[6] == 2560); + assert_or_panic(v[7] == 2561); + assert_or_panic(v[8] == 2562); + assert_or_panic(v[9] == 2563); + assert_or_panic(v[10] == 2564); + assert_or_panic(v[11] == 2565); + assert_or_panic(v[12] == 2566); + assert_or_panic(v[13] == 2567); + assert_or_panic(v[14] == 2568); + assert_or_panic(v[15] == 2569); + assert_or_panic(v[16] == 2570); + assert_or_panic(v[17] == 2571); + assert_or_panic(v[18] == 2572); + assert_or_panic(v[19] == 2573); + assert_or_panic(v[20] == 2574); + assert_or_panic(v[21] == 2575); + assert_or_panic(v[22] == 2576); + assert_or_panic(v[23] == 2577); + assert_or_panic(v[24] == 2578); + assert_or_panic(v[25] == 2579); + assert_or_panic(v[26] == 2580); + assert_or_panic(v[27] == 2581); + assert_or_panic(v[28] == 2582); + assert_or_panic(v[29] == 2583); + assert_or_panic(v[30] == 2584); + assert_or_panic(v[31] == 2585); + assert_or_panic(v[32] == 2586); + assert_or_panic(v[33] == 2587); + assert_or_panic(v[34] == 2588); + assert_or_panic(v[35] == 2589); + assert_or_panic(v[36] == 2590); + assert_or_panic(v[37] == 2591); + assert_or_panic(v[38] == 2592); + assert_or_panic(v[39] == 2593); + assert_or_panic(v[40] == 2594); + assert_or_panic(v[41] == 2595); + assert_or_panic(v[42] == 2596); + assert_or_panic(v[43] == 2597); + assert_or_panic(v[44] == 2598); + assert_or_panic(v[45] == 2599); + assert_or_panic(v[46] == 2600); + assert_or_panic(v[47] == 2601); + assert_or_panic(v[48] == 2602); + assert_or_panic(v[49] == 2603); + assert_or_panic(v[50] == 2604); + assert_or_panic(v[51] == 2605); + assert_or_panic(v[52] == 2606); + assert_or_panic(v[53] == 2607); + assert_or_panic(v[54] == 2608); + assert_or_panic(v[55] == 2609); + assert_or_panic(v[56] == 2610); + assert_or_panic(v[57] == 2611); + assert_or_panic(v[58] == 2612); + assert_or_panic(v[59] == 2613); + assert_or_panic(v[60] == 2614); + assert_or_panic(v[61] == 2615); + assert_or_panic(v[62] == 2616); + assert_or_panic(v[63] == 2617); + assert_or_panic(v[64] == 2618); + assert_or_panic(v[65] == 2619); + assert_or_panic(v[66] == 2620); + assert_or_panic(v[67] == 2621); + assert_or_panic(v[68] == 2622); + assert_or_panic(v[69] == 2623); + assert_or_panic(v[70] == 2624); + assert_or_panic(v[71] == 2625); + assert_or_panic(v[72] == 2626); + assert_or_panic(v[73] == 2627); + assert_or_panic(v[74] == 2628); + assert_or_panic(v[75] == 2629); + assert_or_panic(v[76] == 2630); + assert_or_panic(v[77] == 2631); + assert_or_panic(v[78] == 2632); + assert_or_panic(v[79] == 2633); + assert_or_panic(v[80] == 2634); + assert_or_panic(v[81] == 2635); + assert_or_panic(v[82] == 2636); + assert_or_panic(v[83] == 2637); + assert_or_panic(v[84] == 2638); + assert_or_panic(v[85] == 2639); + assert_or_panic(v[86] == 2640); + assert_or_panic(v[87] == 2641); + assert_or_panic(v[88] == 2642); + assert_or_panic(v[89] == 2643); + assert_or_panic(v[90] == 2644); + assert_or_panic(v[91] == 2645); + assert_or_panic(v[92] == 2646); + assert_or_panic(v[93] == 2647); + assert_or_panic(v[94] == 2648); + assert_or_panic(v[95] == 2649); + assert_or_panic(v[96] == 2650); + assert_or_panic(v[97] == 2651); + assert_or_panic(v[98] == 2652); + assert_or_panic(v[99] == 2653); + assert_or_panic(v[100] == 2654); + assert_or_panic(v[101] == 2655); + assert_or_panic(v[102] == 2656); + assert_or_panic(v[103] == 2657); + assert_or_panic(v[104] == 2658); + assert_or_panic(v[105] == 2659); + assert_or_panic(v[106] == 2660); + assert_or_panic(v[107] == 2661); + assert_or_panic(v[108] == 2662); + assert_or_panic(v[109] == 2663); + assert_or_panic(v[110] == 2664); + assert_or_panic(v[111] == 2665); + assert_or_panic(v[112] == 2666); + assert_or_panic(v[113] == 2667); + assert_or_panic(v[114] == 2668); + assert_or_panic(v[115] == 2669); + assert_or_panic(v[116] == 2670); + assert_or_panic(v[117] == 2671); + assert_or_panic(v[118] == 2672); + assert_or_panic(v[119] == 2673); + assert_or_panic(v[120] == 2674); + assert_or_panic(v[121] == 2675); + assert_or_panic(v[122] == 2676); + assert_or_panic(v[123] == 2677); + assert_or_panic(v[124] == 2678); + assert_or_panic(v[125] == 2679); + assert_or_panic(v[126] == 2680); + assert_or_panic(v[127] == 2681); + assert_or_panic(v[128] == 2682); + assert_or_panic(v[129] == 2683); + assert_or_panic(v[130] == 2684); + assert_or_panic(v[131] == 2685); + assert_or_panic(v[132] == 2686); + assert_or_panic(v[133] == 2687); + assert_or_panic(v[134] == 2688); + assert_or_panic(v[135] == 2689); + assert_or_panic(v[136] == 2690); + assert_or_panic(v[137] == 2691); + assert_or_panic(v[138] == 2692); + assert_or_panic(v[139] == 2693); + assert_or_panic(v[140] == 2694); + assert_or_panic(v[141] == 2695); + assert_or_panic(v[142] == 2696); + assert_or_panic(v[143] == 2697); + assert_or_panic(v[144] == 2698); + assert_or_panic(v[145] == 2699); + assert_or_panic(v[146] == 2700); + assert_or_panic(v[147] == 2701); + assert_or_panic(v[148] == 2702); + assert_or_panic(v[149] == 2703); + assert_or_panic(v[150] == 2704); + assert_or_panic(v[151] == 2705); + assert_or_panic(v[152] == 2706); + assert_or_panic(v[153] == 2707); + assert_or_panic(v[154] == 2708); + assert_or_panic(v[155] == 2709); + assert_or_panic(v[156] == 2710); + assert_or_panic(v[157] == 2711); + assert_or_panic(v[158] == 2712); + assert_or_panic(v[159] == 2713); + assert_or_panic(v[160] == 2714); + assert_or_panic(v[161] == 2715); + assert_or_panic(v[162] == 2716); + assert_or_panic(v[163] == 2717); + assert_or_panic(v[164] == 2718); + assert_or_panic(v[165] == 2719); + assert_or_panic(v[166] == 2720); + assert_or_panic(v[167] == 2721); + assert_or_panic(v[168] == 2722); + assert_or_panic(v[169] == 2723); + assert_or_panic(v[170] == 2724); + assert_or_panic(v[171] == 2725); + assert_or_panic(v[172] == 2726); + assert_or_panic(v[173] == 2727); + assert_or_panic(v[174] == 2728); + assert_or_panic(v[175] == 2729); + assert_or_panic(v[176] == 2730); + assert_or_panic(v[177] == 2731); + assert_or_panic(v[178] == 2732); + assert_or_panic(v[179] == 2733); + assert_or_panic(v[180] == 2734); + assert_or_panic(v[181] == 2735); + assert_or_panic(v[182] == 2736); + assert_or_panic(v[183] == 2737); + assert_or_panic(v[184] == 2738); + assert_or_panic(v[185] == 2739); + assert_or_panic(v[186] == 2740); + assert_or_panic(v[187] == 2741); + assert_or_panic(v[188] == 2742); + assert_or_panic(v[189] == 2743); + assert_or_panic(v[190] == 2744); + assert_or_panic(v[191] == 2745); + assert_or_panic(v[192] == 2746); + assert_or_panic(v[193] == 2747); + assert_or_panic(v[194] == 2748); + assert_or_panic(v[195] == 2749); + assert_or_panic(v[196] == 2750); + assert_or_panic(v[197] == 2751); + assert_or_panic(v[198] == 2752); + assert_or_panic(v[199] == 2753); + assert_or_panic(v[200] == 2754); + assert_or_panic(v[201] == 2755); + assert_or_panic(v[202] == 2756); + assert_or_panic(v[203] == 2757); + assert_or_panic(v[204] == 2758); + assert_or_panic(v[205] == 2759); + assert_or_panic(v[206] == 2760); + assert_or_panic(v[207] == 2761); + assert_or_panic(v[208] == 2762); + assert_or_panic(v[209] == 2763); + assert_or_panic(v[210] == 2764); + assert_or_panic(v[211] == 2765); + assert_or_panic(v[212] == 2766); + assert_or_panic(v[213] == 2767); + assert_or_panic(v[214] == 2768); + assert_or_panic(v[215] == 2769); + assert_or_panic(v[216] == 2770); + assert_or_panic(v[217] == 2771); + assert_or_panic(v[218] == 2772); + assert_or_panic(v[219] == 2773); + assert_or_panic(v[220] == 2774); + assert_or_panic(v[221] == 2775); + assert_or_panic(v[222] == 2776); + assert_or_panic(v[223] == 2777); + assert_or_panic(v[224] == 2778); + assert_or_panic(v[225] == 2779); + assert_or_panic(v[226] == 2780); + assert_or_panic(v[227] == 2781); + assert_or_panic(v[228] == 2782); + assert_or_panic(v[229] == 2783); + assert_or_panic(v[230] == 2784); + assert_or_panic(v[231] == 2785); + assert_or_panic(v[232] == 2786); + assert_or_panic(v[233] == 2787); + assert_or_panic(v[234] == 2788); + assert_or_panic(v[235] == 2789); + assert_or_panic(v[236] == 2790); + assert_or_panic(v[237] == 2791); + assert_or_panic(v[238] == 2792); + assert_or_panic(v[239] == 2793); + assert_or_panic(v[240] == 2794); + assert_or_panic(v[241] == 2795); + assert_or_panic(v[242] == 2796); + assert_or_panic(v[243] == 2797); + assert_or_panic(v[244] == 2798); + assert_or_panic(v[245] == 2799); + assert_or_panic(v[246] == 2800); + assert_or_panic(v[247] == 2801); + assert_or_panic(v[248] == 2802); + assert_or_panic(v[249] == 2803); + assert_or_panic(v[250] == 2804); + assert_or_panic(v[251] == 2805); + assert_or_panic(v[252] == 2806); + assert_or_panic(v[253] == 2807); + assert_or_panic(v[254] == 2808); + assert_or_panic(v[255] == 2809); + zig_vector_256_u16((Vector_256_u16){ + 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, + 2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, + 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, + 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873, + 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889, + 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, + 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, + 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, + 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, + 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969, + 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985, + 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001, + 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, + 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, + 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, + 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065, + }, 256); +} + +typedef uint32_t Vector_1_u32 __attribute__((vector_size(1 * sizeof(uint32_t)))); + +Vector_1_u32 zig_ret_vector_1_u32(void); +void zig_vector_1_u32(Vector_1_u32, size_t); + +Vector_1_u32 c_ret_vector_1_u32(void) { + return (Vector_1_u32){ 3 }; +} +void c_vector_1_u32(Vector_1_u32 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_u32(void) { + Vector_1_u32 v = zig_ret_vector_1_u32(); + assert_or_panic(v[0] == 1); + zig_vector_1_u32((Vector_1_u32){ 2 }, 1); +} + +typedef uint32_t Vector_2_u32 __attribute__((vector_size(2 * sizeof(uint32_t)))); + +Vector_2_u32 zig_ret_vector_2_u32(void); +void zig_vector_2_u32(Vector_2_u32, size_t); + +Vector_2_u32 c_ret_vector_2_u32(void) { + return (Vector_2_u32){ 9, 10 }; +} +void c_vector_2_u32(Vector_2_u32 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_u32(void) { + Vector_2_u32 v = zig_ret_vector_2_u32(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_u32((Vector_2_u32){ 7, 8 }, 2); +} + +typedef uint32_t Vector_3_u32 __attribute__((vector_size(3 * sizeof(uint32_t)))); + +Vector_3_u32 zig_ret_vector_3_u32(void); +void zig_vector_3_u32(Vector_3_u32, size_t); + +Vector_3_u32 c_ret_vector_3_u32(void) { + return (Vector_3_u32){ 19, 20, 21 }; +} +void c_vector_3_u32(Vector_3_u32 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 3); +} +void c_test_vector_3_u32(void) { + Vector_3_u32 v = zig_ret_vector_3_u32(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_u32((Vector_3_u32){ 16, 17, 18 }, 3); +} + +typedef uint32_t Vector_4_u32 __attribute__((vector_size(4 * sizeof(uint32_t)))); + +Vector_4_u32 zig_ret_vector_4_u32(void); + +void zig_vector_4_u32(Vector_4_u32, size_t); +void zig_vector_4_u32_vector_4_u32(Vector_4_u32, Vector_4_u32, size_t); + +Vector_4_u32 c_ret_vector_4_u32(void) { + return (Vector_4_u32){ 41, 42, 43, 44 }; +} +void c_vector_4_u32(Vector_4_u32 v, size_t i) { + assert_or_panic(v[0] == 45); + assert_or_panic(v[1] == 46); + assert_or_panic(v[2] == 47); + assert_or_panic(v[3] == 48); + assert_or_panic(i == 4); +} +void c_vector_4_u32_vector_4_u32(Vector_4_u32 v0, Vector_4_u32 v1, size_t i) { + assert_or_panic(v0[0] == 49); + assert_or_panic(v0[1] == 50); + assert_or_panic(v0[2] == 51); + assert_or_panic(v0[3] == 52); + assert_or_panic(v1[0] == 53); + assert_or_panic(v1[1] == 54); + assert_or_panic(v1[2] == 55); + assert_or_panic(v1[3] == 56); + assert_or_panic(i == 8); +} +void c_test_vector_4_u32(void) { + Vector_4_u32 v = zig_ret_vector_4_u32(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_u32((Vector_4_u32){ 29, 30, 31, 32 }, 4); + zig_vector_4_u32_vector_4_u32((Vector_4_u32){ 33, 34, 35, 36 }, (Vector_4_u32){ 37, 38, 39, 40 }, 8); +} + +typedef uint32_t Vector_6_u32 __attribute__((vector_size(6 * sizeof(uint32_t)))); + +Vector_6_u32 zig_ret_vector_6_u32(void); +void zig_vector_6_u32(Vector_6_u32, size_t); + +Vector_6_u32 c_ret_vector_6_u32(void) { + return (Vector_6_u32){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_u32(Vector_6_u32 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_u32(void) { + Vector_6_u32 v = zig_ret_vector_6_u32(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_u32((Vector_6_u32){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef uint32_t Vector_8_u32 __attribute__((vector_size(8 * sizeof(uint32_t)))); + +Vector_8_u32 zig_ret_vector_8_u32(void); +void zig_vector_8_u32(Vector_8_u32, size_t); + +Vector_8_u32 c_ret_vector_8_u32(void) { + return (Vector_8_u32){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_u32(Vector_8_u32 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_u32(void) { + Vector_8_u32 v = zig_ret_vector_8_u32(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_u32((Vector_8_u32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef uint32_t Vector_12_u32 __attribute__((vector_size(12 * sizeof(uint32_t)))); + +Vector_12_u32 zig_ret_vector_12_u32(void); +void zig_vector_12_u32(Vector_12_u32, size_t); + +Vector_12_u32 c_ret_vector_12_u32(void) { + return (Vector_12_u32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 }; +} +void c_vector_12_u32(Vector_12_u32 v, size_t i) { + assert_or_panic(v[0] == 133); + assert_or_panic(v[1] == 134); + assert_or_panic(v[2] == 135); + assert_or_panic(v[3] == 136); + assert_or_panic(v[4] == 137); + assert_or_panic(v[5] == 138); + assert_or_panic(v[6] == 139); + assert_or_panic(v[7] == 140); + assert_or_panic(v[8] == 141); + assert_or_panic(v[9] == 142); + assert_or_panic(v[10] == 143); + assert_or_panic(v[11] == 144); + assert_or_panic(i == 12); +} +void c_test_vector_12_u32(void) { + Vector_12_u32 v = zig_ret_vector_12_u32(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 100); + assert_or_panic(v[4] == 101); + assert_or_panic(v[5] == 102); + assert_or_panic(v[6] == 103); + assert_or_panic(v[7] == 104); + assert_or_panic(v[8] == 105); + assert_or_panic(v[9] == 106); + assert_or_panic(v[10] == 107); + assert_or_panic(v[11] == 108); + zig_vector_12_u32((Vector_12_u32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12); +} + +typedef uint32_t Vector_16_u32 __attribute__((vector_size(16 * sizeof(uint32_t)))); + +Vector_16_u32 zig_ret_vector_16_u32(void); +void zig_vector_16_u32(Vector_16_u32, size_t); + +Vector_16_u32 c_ret_vector_16_u32(void) { + return (Vector_16_u32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 }; +} +void c_vector_16_u32(Vector_16_u32 v, size_t i) { + assert_or_panic(v[0] == 193); + assert_or_panic(v[1] == 194); + assert_or_panic(v[2] == 195); + assert_or_panic(v[3] == 196); + assert_or_panic(v[4] == 197); + assert_or_panic(v[5] == 198); + assert_or_panic(v[6] == 199); + assert_or_panic(v[7] == 200); + assert_or_panic(v[8] == 201); + assert_or_panic(v[9] == 202); + assert_or_panic(v[10] == 203); + assert_or_panic(v[11] == 204); + assert_or_panic(v[12] == 205); + assert_or_panic(v[13] == 206); + assert_or_panic(v[14] == 207); + assert_or_panic(v[15] == 208); + assert_or_panic(i == 16); +} +void c_test_vector_16_u32(void) { + Vector_16_u32 v = zig_ret_vector_16_u32(); + assert_or_panic(v[0] == 145); + assert_or_panic(v[1] == 146); + assert_or_panic(v[2] == 147); + assert_or_panic(v[3] == 148); + assert_or_panic(v[4] == 149); + assert_or_panic(v[5] == 150); + assert_or_panic(v[6] == 151); + assert_or_panic(v[7] == 152); + assert_or_panic(v[8] == 153); + assert_or_panic(v[9] == 154); + assert_or_panic(v[10] == 155); + assert_or_panic(v[11] == 156); + assert_or_panic(v[12] == 157); + assert_or_panic(v[13] == 158); + assert_or_panic(v[14] == 159); + assert_or_panic(v[15] == 160); + zig_vector_16_u32((Vector_16_u32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16); +} + +typedef uint32_t Vector_24_u32 __attribute__((vector_size(24 * sizeof(uint32_t)))); + +Vector_24_u32 zig_ret_vector_24_u32(void); +void zig_vector_24_u32(Vector_24_u32, size_t); + +Vector_24_u32 c_ret_vector_24_u32(void) { + return (Vector_24_u32){ + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, + }; +} +void c_vector_24_u32(Vector_24_u32 v, size_t i) { + assert_or_panic(v[0] == 281); + assert_or_panic(v[1] == 282); + assert_or_panic(v[2] == 283); + assert_or_panic(v[3] == 284); + assert_or_panic(v[4] == 285); + assert_or_panic(v[5] == 286); + assert_or_panic(v[6] == 287); + assert_or_panic(v[7] == 288); + assert_or_panic(v[8] == 289); + assert_or_panic(v[9] == 290); + assert_or_panic(v[10] == 291); + assert_or_panic(v[11] == 292); + assert_or_panic(v[12] == 293); + assert_or_panic(v[13] == 294); + assert_or_panic(v[14] == 295); + assert_or_panic(v[15] == 296); + assert_or_panic(v[16] == 297); + assert_or_panic(v[17] == 298); + assert_or_panic(v[18] == 299); + assert_or_panic(v[19] == 300); + assert_or_panic(v[20] == 301); + assert_or_panic(v[21] == 302); + assert_or_panic(v[22] == 303); + assert_or_panic(v[23] == 304); + assert_or_panic(i == 24); +} +void c_test_vector_24_u32(void) { + Vector_24_u32 v = zig_ret_vector_24_u32(); + assert_or_panic(v[0] == 209); + assert_or_panic(v[1] == 210); + assert_or_panic(v[2] == 211); + assert_or_panic(v[3] == 212); + assert_or_panic(v[4] == 213); + assert_or_panic(v[5] == 214); + assert_or_panic(v[6] == 215); + assert_or_panic(v[7] == 216); + assert_or_panic(v[8] == 217); + assert_or_panic(v[9] == 218); + assert_or_panic(v[10] == 219); + assert_or_panic(v[11] == 220); + assert_or_panic(v[12] == 221); + assert_or_panic(v[13] == 222); + assert_or_panic(v[14] == 223); + assert_or_panic(v[15] == 224); + assert_or_panic(v[16] == 225); + assert_or_panic(v[17] == 226); + assert_or_panic(v[18] == 227); + assert_or_panic(v[19] == 228); + assert_or_panic(v[20] == 229); + assert_or_panic(v[21] == 230); + assert_or_panic(v[22] == 231); + assert_or_panic(v[23] == 232); + zig_vector_24_u32((Vector_24_u32){ + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, + }, 24); +} + +typedef uint32_t Vector_32_u32 __attribute__((vector_size(32 * sizeof(uint32_t)))); + +Vector_32_u32 zig_ret_vector_32_u32(void); +void zig_vector_32_u32(Vector_32_u32, size_t); + +Vector_32_u32 c_ret_vector_32_u32(void) { + return (Vector_32_u32){ + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + }; +} +void c_vector_32_u32(Vector_32_u32 v, size_t i) { + assert_or_panic(v[0] == 401); + assert_or_panic(v[1] == 402); + assert_or_panic(v[2] == 403); + assert_or_panic(v[3] == 404); + assert_or_panic(v[4] == 405); + assert_or_panic(v[5] == 406); + assert_or_panic(v[6] == 407); + assert_or_panic(v[7] == 408); + assert_or_panic(v[8] == 409); + assert_or_panic(v[9] == 410); + assert_or_panic(v[10] == 411); + assert_or_panic(v[11] == 412); + assert_or_panic(v[12] == 413); + assert_or_panic(v[13] == 414); + assert_or_panic(v[14] == 415); + assert_or_panic(v[15] == 416); + assert_or_panic(v[16] == 417); + assert_or_panic(v[17] == 418); + assert_or_panic(v[18] == 419); + assert_or_panic(v[19] == 420); + assert_or_panic(v[20] == 421); + assert_or_panic(v[21] == 422); + assert_or_panic(v[22] == 423); + assert_or_panic(v[23] == 424); + assert_or_panic(v[24] == 425); + assert_or_panic(v[25] == 426); + assert_or_panic(v[26] == 427); + assert_or_panic(v[27] == 428); + assert_or_panic(v[28] == 429); + assert_or_panic(v[29] == 430); + assert_or_panic(v[30] == 431); + assert_or_panic(v[31] == 432); + assert_or_panic(i == 32); +} +void c_test_vector_32_u32(void) { + Vector_32_u32 v = zig_ret_vector_32_u32(); + assert_or_panic(v[0] == 305); + assert_or_panic(v[1] == 306); + assert_or_panic(v[2] == 307); + assert_or_panic(v[3] == 308); + assert_or_panic(v[4] == 309); + assert_or_panic(v[5] == 310); + assert_or_panic(v[6] == 311); + assert_or_panic(v[7] == 312); + assert_or_panic(v[8] == 313); + assert_or_panic(v[9] == 314); + assert_or_panic(v[10] == 315); + assert_or_panic(v[11] == 316); + assert_or_panic(v[12] == 317); + assert_or_panic(v[13] == 318); + assert_or_panic(v[14] == 319); + assert_or_panic(v[15] == 320); + assert_or_panic(v[16] == 321); + assert_or_panic(v[17] == 322); + assert_or_panic(v[18] == 323); + assert_or_panic(v[19] == 324); + assert_or_panic(v[20] == 325); + assert_or_panic(v[21] == 326); + assert_or_panic(v[22] == 327); + assert_or_panic(v[23] == 328); + assert_or_panic(v[24] == 329); + assert_or_panic(v[25] == 330); + assert_or_panic(v[26] == 331); + assert_or_panic(v[27] == 332); + assert_or_panic(v[28] == 333); + assert_or_panic(v[29] == 334); + assert_or_panic(v[30] == 335); + assert_or_panic(v[31] == 336); + zig_vector_32_u32((Vector_32_u32){ + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + }, 32); +} + +typedef uint32_t Vector_48_u32 __attribute__((vector_size(48 * sizeof(uint32_t)))); + +Vector_48_u32 zig_ret_vector_48_u32(void); +void zig_vector_48_u32(Vector_48_u32, size_t); + +Vector_48_u32 c_ret_vector_48_u32(void) { + return (Vector_48_u32){ + 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, + }; +} +void c_vector_48_u32(Vector_48_u32 v, size_t i) { + assert_or_panic(v[0] == 577); + assert_or_panic(v[1] == 578); + assert_or_panic(v[2] == 579); + assert_or_panic(v[3] == 580); + assert_or_panic(v[4] == 581); + assert_or_panic(v[5] == 582); + assert_or_panic(v[6] == 583); + assert_or_panic(v[7] == 584); + assert_or_panic(v[8] == 585); + assert_or_panic(v[9] == 586); + assert_or_panic(v[10] == 587); + assert_or_panic(v[11] == 588); + assert_or_panic(v[12] == 589); + assert_or_panic(v[13] == 590); + assert_or_panic(v[14] == 591); + assert_or_panic(v[15] == 592); + assert_or_panic(v[16] == 593); + assert_or_panic(v[17] == 594); + assert_or_panic(v[18] == 595); + assert_or_panic(v[19] == 596); + assert_or_panic(v[20] == 597); + assert_or_panic(v[21] == 598); + assert_or_panic(v[22] == 599); + assert_or_panic(v[23] == 600); + assert_or_panic(v[24] == 601); + assert_or_panic(v[25] == 602); + assert_or_panic(v[26] == 603); + assert_or_panic(v[27] == 604); + assert_or_panic(v[28] == 605); + assert_or_panic(v[29] == 606); + assert_or_panic(v[30] == 607); + assert_or_panic(v[31] == 608); + assert_or_panic(v[32] == 609); + assert_or_panic(v[33] == 610); + assert_or_panic(v[34] == 611); + assert_or_panic(v[35] == 612); + assert_or_panic(v[36] == 613); + assert_or_panic(v[37] == 614); + assert_or_panic(v[38] == 615); + assert_or_panic(v[39] == 616); + assert_or_panic(v[40] == 617); + assert_or_panic(v[41] == 618); + assert_or_panic(v[42] == 619); + assert_or_panic(v[43] == 620); + assert_or_panic(v[44] == 621); + assert_or_panic(v[45] == 622); + assert_or_panic(v[46] == 623); + assert_or_panic(v[47] == 624); + assert_or_panic(i == 48); +} +void c_test_vector_48_u32(void) { + Vector_48_u32 v = zig_ret_vector_48_u32(); + assert_or_panic(v[0] == 433); + assert_or_panic(v[1] == 434); + assert_or_panic(v[2] == 435); + assert_or_panic(v[3] == 436); + assert_or_panic(v[4] == 437); + assert_or_panic(v[5] == 438); + assert_or_panic(v[6] == 439); + assert_or_panic(v[7] == 440); + assert_or_panic(v[8] == 441); + assert_or_panic(v[9] == 442); + assert_or_panic(v[10] == 443); + assert_or_panic(v[11] == 444); + assert_or_panic(v[12] == 445); + assert_or_panic(v[13] == 446); + assert_or_panic(v[14] == 447); + assert_or_panic(v[15] == 448); + assert_or_panic(v[16] == 449); + assert_or_panic(v[17] == 450); + assert_or_panic(v[18] == 451); + assert_or_panic(v[19] == 452); + assert_or_panic(v[20] == 453); + assert_or_panic(v[21] == 454); + assert_or_panic(v[22] == 455); + assert_or_panic(v[23] == 456); + assert_or_panic(v[24] == 457); + assert_or_panic(v[25] == 458); + assert_or_panic(v[26] == 459); + assert_or_panic(v[27] == 460); + assert_or_panic(v[28] == 461); + assert_or_panic(v[29] == 462); + assert_or_panic(v[30] == 463); + assert_or_panic(v[31] == 464); + assert_or_panic(v[32] == 465); + assert_or_panic(v[33] == 466); + assert_or_panic(v[34] == 467); + assert_or_panic(v[35] == 468); + assert_or_panic(v[36] == 469); + assert_or_panic(v[37] == 470); + assert_or_panic(v[38] == 471); + assert_or_panic(v[39] == 472); + assert_or_panic(v[40] == 473); + assert_or_panic(v[41] == 474); + assert_or_panic(v[42] == 475); + assert_or_panic(v[43] == 476); + assert_or_panic(v[44] == 477); + assert_or_panic(v[45] == 478); + assert_or_panic(v[46] == 479); + assert_or_panic(v[47] == 480); + zig_vector_48_u32((Vector_48_u32){ + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + }, 48); +} + +typedef uint32_t Vector_64_u32 __attribute__((vector_size(64 * sizeof(uint32_t)))); + +Vector_64_u32 zig_ret_vector_64_u32(void); +void zig_vector_64_u32(Vector_64_u32, size_t); + +Vector_64_u32 c_ret_vector_64_u32(void) { + return (Vector_64_u32){ + 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, + 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, + }; +} +void c_vector_64_u32(Vector_64_u32 v, size_t i) { + assert_or_panic(v[0] == 817); + assert_or_panic(v[1] == 818); + assert_or_panic(v[2] == 819); + assert_or_panic(v[3] == 820); + assert_or_panic(v[4] == 821); + assert_or_panic(v[5] == 822); + assert_or_panic(v[6] == 823); + assert_or_panic(v[7] == 824); + assert_or_panic(v[8] == 825); + assert_or_panic(v[9] == 826); + assert_or_panic(v[10] == 827); + assert_or_panic(v[11] == 828); + assert_or_panic(v[12] == 829); + assert_or_panic(v[13] == 830); + assert_or_panic(v[14] == 831); + assert_or_panic(v[15] == 832); + assert_or_panic(v[16] == 833); + assert_or_panic(v[17] == 834); + assert_or_panic(v[18] == 835); + assert_or_panic(v[19] == 836); + assert_or_panic(v[20] == 837); + assert_or_panic(v[21] == 838); + assert_or_panic(v[22] == 839); + assert_or_panic(v[23] == 840); + assert_or_panic(v[24] == 841); + assert_or_panic(v[25] == 842); + assert_or_panic(v[26] == 843); + assert_or_panic(v[27] == 844); + assert_or_panic(v[28] == 845); + assert_or_panic(v[29] == 846); + assert_or_panic(v[30] == 847); + assert_or_panic(v[31] == 848); + assert_or_panic(v[32] == 849); + assert_or_panic(v[33] == 850); + assert_or_panic(v[34] == 851); + assert_or_panic(v[35] == 852); + assert_or_panic(v[36] == 853); + assert_or_panic(v[37] == 854); + assert_or_panic(v[38] == 855); + assert_or_panic(v[39] == 856); + assert_or_panic(v[40] == 857); + assert_or_panic(v[41] == 858); + assert_or_panic(v[42] == 859); + assert_or_panic(v[43] == 860); + assert_or_panic(v[44] == 861); + assert_or_panic(v[45] == 862); + assert_or_panic(v[46] == 863); + assert_or_panic(v[47] == 864); + assert_or_panic(v[48] == 865); + assert_or_panic(v[49] == 866); + assert_or_panic(v[50] == 867); + assert_or_panic(v[51] == 868); + assert_or_panic(v[52] == 869); + assert_or_panic(v[53] == 870); + assert_or_panic(v[54] == 871); + assert_or_panic(v[55] == 872); + assert_or_panic(v[56] == 873); + assert_or_panic(v[57] == 874); + assert_or_panic(v[58] == 875); + assert_or_panic(v[59] == 876); + assert_or_panic(v[60] == 877); + assert_or_panic(v[61] == 878); + assert_or_panic(v[62] == 879); + assert_or_panic(v[63] == 880); + assert_or_panic(i == 64); +} +void c_test_vector_64_u32(void) { + Vector_64_u32 v = zig_ret_vector_64_u32(); + assert_or_panic(v[0] == 625); + assert_or_panic(v[1] == 626); + assert_or_panic(v[2] == 627); + assert_or_panic(v[3] == 628); + assert_or_panic(v[4] == 629); + assert_or_panic(v[5] == 630); + assert_or_panic(v[6] == 631); + assert_or_panic(v[7] == 632); + assert_or_panic(v[8] == 633); + assert_or_panic(v[9] == 634); + assert_or_panic(v[10] == 635); + assert_or_panic(v[11] == 636); + assert_or_panic(v[12] == 637); + assert_or_panic(v[13] == 638); + assert_or_panic(v[14] == 639); + assert_or_panic(v[15] == 640); + assert_or_panic(v[16] == 641); + assert_or_panic(v[17] == 642); + assert_or_panic(v[18] == 643); + assert_or_panic(v[19] == 644); + assert_or_panic(v[20] == 645); + assert_or_panic(v[21] == 646); + assert_or_panic(v[22] == 647); + assert_or_panic(v[23] == 648); + assert_or_panic(v[24] == 649); + assert_or_panic(v[25] == 650); + assert_or_panic(v[26] == 651); + assert_or_panic(v[27] == 652); + assert_or_panic(v[28] == 653); + assert_or_panic(v[29] == 654); + assert_or_panic(v[30] == 655); + assert_or_panic(v[31] == 656); + assert_or_panic(v[32] == 657); + assert_or_panic(v[33] == 658); + assert_or_panic(v[34] == 659); + assert_or_panic(v[35] == 660); + assert_or_panic(v[36] == 661); + assert_or_panic(v[37] == 662); + assert_or_panic(v[38] == 663); + assert_or_panic(v[39] == 664); + assert_or_panic(v[40] == 665); + assert_or_panic(v[41] == 666); + assert_or_panic(v[42] == 667); + assert_or_panic(v[43] == 668); + assert_or_panic(v[44] == 669); + assert_or_panic(v[45] == 670); + assert_or_panic(v[46] == 671); + assert_or_panic(v[47] == 672); + assert_or_panic(v[48] == 673); + assert_or_panic(v[49] == 674); + assert_or_panic(v[50] == 675); + assert_or_panic(v[51] == 676); + assert_or_panic(v[52] == 677); + assert_or_panic(v[53] == 678); + assert_or_panic(v[54] == 679); + assert_or_panic(v[55] == 680); + assert_or_panic(v[56] == 681); + assert_or_panic(v[57] == 682); + assert_or_panic(v[58] == 683); + assert_or_panic(v[59] == 684); + assert_or_panic(v[60] == 685); + assert_or_panic(v[61] == 686); + assert_or_panic(v[62] == 687); + assert_or_panic(v[63] == 688); + zig_vector_64_u32((Vector_64_u32){ + 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, + 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, + }, 64); +} + +typedef uint32_t Vector_96_u32 __attribute__((vector_size(96 * sizeof(uint32_t)))); + +Vector_96_u32 zig_ret_vector_96_u32(void); +void zig_vector_96_u32(Vector_96_u32, size_t); + +Vector_96_u32 c_ret_vector_96_u32(void) { + return (Vector_96_u32){ + 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, + 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, + 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, + 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, + 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, + 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, + }; +} +void c_vector_96_u32(Vector_96_u32 v, size_t i) { + assert_or_panic(v[0] == 1178); + assert_or_panic(v[1] == 1179); + assert_or_panic(v[2] == 1180); + assert_or_panic(v[3] == 1181); + assert_or_panic(v[4] == 1182); + assert_or_panic(v[5] == 1183); + assert_or_panic(v[6] == 1184); + assert_or_panic(v[7] == 1185); + assert_or_panic(v[8] == 1186); + assert_or_panic(v[9] == 1187); + assert_or_panic(v[10] == 1188); + assert_or_panic(v[11] == 1189); + assert_or_panic(v[12] == 1190); + assert_or_panic(v[13] == 1191); + assert_or_panic(v[14] == 1192); + assert_or_panic(v[15] == 1193); + assert_or_panic(v[16] == 1194); + assert_or_panic(v[17] == 1195); + assert_or_panic(v[18] == 1196); + assert_or_panic(v[19] == 1197); + assert_or_panic(v[20] == 1198); + assert_or_panic(v[21] == 1199); + assert_or_panic(v[22] == 1200); + assert_or_panic(v[23] == 1201); + assert_or_panic(v[24] == 1202); + assert_or_panic(v[25] == 1203); + assert_or_panic(v[26] == 1204); + assert_or_panic(v[27] == 1205); + assert_or_panic(v[28] == 1206); + assert_or_panic(v[29] == 1207); + assert_or_panic(v[30] == 1208); + assert_or_panic(v[31] == 1209); + assert_or_panic(v[32] == 1210); + assert_or_panic(v[33] == 1211); + assert_or_panic(v[34] == 1212); + assert_or_panic(v[35] == 1213); + assert_or_panic(v[36] == 1214); + assert_or_panic(v[37] == 1215); + assert_or_panic(v[38] == 1216); + assert_or_panic(v[39] == 1217); + assert_or_panic(v[40] == 1218); + assert_or_panic(v[41] == 1219); + assert_or_panic(v[42] == 1220); + assert_or_panic(v[43] == 1221); + assert_or_panic(v[44] == 1222); + assert_or_panic(v[45] == 1223); + assert_or_panic(v[46] == 1224); + assert_or_panic(v[47] == 1225); + assert_or_panic(v[48] == 1226); + assert_or_panic(v[49] == 1227); + assert_or_panic(v[50] == 1228); + assert_or_panic(v[51] == 1229); + assert_or_panic(v[52] == 1230); + assert_or_panic(v[53] == 1231); + assert_or_panic(v[54] == 1232); + assert_or_panic(v[55] == 1233); + assert_or_panic(v[56] == 1234); + assert_or_panic(v[57] == 1235); + assert_or_panic(v[58] == 1236); + assert_or_panic(v[59] == 1237); + assert_or_panic(v[60] == 1238); + assert_or_panic(v[61] == 1239); + assert_or_panic(v[62] == 1240); + assert_or_panic(v[63] == 1241); + assert_or_panic(v[64] == 1242); + assert_or_panic(v[65] == 1243); + assert_or_panic(v[66] == 1244); + assert_or_panic(v[67] == 1245); + assert_or_panic(v[68] == 1246); + assert_or_panic(v[69] == 1247); + assert_or_panic(v[70] == 1248); + assert_or_panic(v[71] == 1249); + assert_or_panic(v[72] == 1250); + assert_or_panic(v[73] == 1251); + assert_or_panic(v[74] == 1252); + assert_or_panic(v[75] == 1253); + assert_or_panic(v[76] == 1254); + assert_or_panic(v[77] == 1255); + assert_or_panic(v[80] == 1258); + assert_or_panic(v[81] == 1259); + assert_or_panic(v[82] == 1260); + assert_or_panic(v[83] == 1261); + assert_or_panic(v[84] == 1262); + assert_or_panic(v[85] == 1263); + assert_or_panic(v[86] == 1264); + assert_or_panic(v[87] == 1265); + assert_or_panic(v[88] == 1266); + assert_or_panic(v[89] == 1267); + assert_or_panic(v[90] == 1268); + assert_or_panic(v[91] == 1269); + assert_or_panic(v[92] == 1270); + assert_or_panic(v[93] == 1271); + assert_or_panic(v[94] == 1272); + assert_or_panic(v[95] == 1273); + assert_or_panic(i == 96); +} +void c_test_vector_96_u32(void) { + Vector_96_u32 v = zig_ret_vector_96_u32(); + assert_or_panic(v[0] == 890); + assert_or_panic(v[1] == 891); + assert_or_panic(v[2] == 892); + assert_or_panic(v[3] == 893); + assert_or_panic(v[4] == 894); + assert_or_panic(v[5] == 895); + assert_or_panic(v[6] == 896); + assert_or_panic(v[7] == 897); + assert_or_panic(v[8] == 898); + assert_or_panic(v[9] == 899); + assert_or_panic(v[10] == 900); + assert_or_panic(v[11] == 901); + assert_or_panic(v[12] == 902); + assert_or_panic(v[13] == 903); + assert_or_panic(v[14] == 904); + assert_or_panic(v[15] == 905); + assert_or_panic(v[16] == 906); + assert_or_panic(v[17] == 907); + assert_or_panic(v[18] == 908); + assert_or_panic(v[19] == 909); + assert_or_panic(v[20] == 910); + assert_or_panic(v[21] == 911); + assert_or_panic(v[22] == 912); + assert_or_panic(v[23] == 913); + assert_or_panic(v[24] == 914); + assert_or_panic(v[25] == 915); + assert_or_panic(v[26] == 916); + assert_or_panic(v[27] == 917); + assert_or_panic(v[28] == 918); + assert_or_panic(v[29] == 919); + assert_or_panic(v[30] == 920); + assert_or_panic(v[31] == 921); + assert_or_panic(v[32] == 922); + assert_or_panic(v[33] == 923); + assert_or_panic(v[34] == 924); + assert_or_panic(v[35] == 925); + assert_or_panic(v[36] == 926); + assert_or_panic(v[37] == 927); + assert_or_panic(v[38] == 928); + assert_or_panic(v[39] == 929); + assert_or_panic(v[40] == 930); + assert_or_panic(v[41] == 931); + assert_or_panic(v[42] == 932); + assert_or_panic(v[43] == 933); + assert_or_panic(v[44] == 934); + assert_or_panic(v[45] == 935); + assert_or_panic(v[46] == 936); + assert_or_panic(v[47] == 937); + assert_or_panic(v[48] == 938); + assert_or_panic(v[49] == 939); + assert_or_panic(v[50] == 940); + assert_or_panic(v[51] == 941); + assert_or_panic(v[52] == 942); + assert_or_panic(v[53] == 943); + assert_or_panic(v[54] == 944); + assert_or_panic(v[55] == 945); + assert_or_panic(v[56] == 946); + assert_or_panic(v[57] == 947); + assert_or_panic(v[58] == 948); + assert_or_panic(v[59] == 949); + assert_or_panic(v[60] == 950); + assert_or_panic(v[61] == 951); + assert_or_panic(v[62] == 952); + assert_or_panic(v[63] == 953); + assert_or_panic(v[64] == 954); + assert_or_panic(v[65] == 955); + assert_or_panic(v[66] == 956); + assert_or_panic(v[67] == 957); + assert_or_panic(v[68] == 958); + assert_or_panic(v[69] == 959); + assert_or_panic(v[70] == 960); + assert_or_panic(v[71] == 961); + assert_or_panic(v[72] == 962); + assert_or_panic(v[73] == 963); + assert_or_panic(v[74] == 964); + assert_or_panic(v[75] == 965); + assert_or_panic(v[76] == 966); + assert_or_panic(v[77] == 967); + assert_or_panic(v[78] == 968); + assert_or_panic(v[79] == 969); + assert_or_panic(v[80] == 970); + assert_or_panic(v[81] == 971); + assert_or_panic(v[82] == 972); + assert_or_panic(v[83] == 973); + assert_or_panic(v[84] == 974); + assert_or_panic(v[85] == 975); + assert_or_panic(v[86] == 976); + assert_or_panic(v[87] == 977); + assert_or_panic(v[88] == 978); + assert_or_panic(v[89] == 979); + assert_or_panic(v[90] == 980); + assert_or_panic(v[91] == 981); + assert_or_panic(v[92] == 982); + assert_or_panic(v[93] == 983); + assert_or_panic(v[94] == 984); + assert_or_panic(v[95] == 985); + zig_vector_96_u32((Vector_96_u32){ + 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, + 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, + 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, + 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, + 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, + 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, + }, 96); +} + +typedef uint32_t Vector_128_u32 __attribute__((vector_size(128 * sizeof(uint32_t)))); + +Vector_128_u32 zig_ret_vector_128_u32(void); +void zig_vector_128_u32(Vector_128_u32, size_t); + +Vector_128_u32 c_ret_vector_128_u32(void) { + return (Vector_128_u32){ + 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, + 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, + 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, + 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, + 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, + }; +} +void c_vector_128_u32(Vector_128_u32 v, size_t i) { + assert_or_panic(v[0] == 1658); + assert_or_panic(v[1] == 1659); + assert_or_panic(v[2] == 1660); + assert_or_panic(v[3] == 1661); + assert_or_panic(v[4] == 1662); + assert_or_panic(v[5] == 1663); + assert_or_panic(v[6] == 1664); + assert_or_panic(v[7] == 1665); + assert_or_panic(v[8] == 1666); + assert_or_panic(v[9] == 1667); + assert_or_panic(v[10] == 1668); + assert_or_panic(v[11] == 1669); + assert_or_panic(v[12] == 1670); + assert_or_panic(v[13] == 1671); + assert_or_panic(v[14] == 1672); + assert_or_panic(v[15] == 1673); + assert_or_panic(v[16] == 1674); + assert_or_panic(v[17] == 1675); + assert_or_panic(v[18] == 1676); + assert_or_panic(v[19] == 1677); + assert_or_panic(v[20] == 1678); + assert_or_panic(v[21] == 1679); + assert_or_panic(v[22] == 1680); + assert_or_panic(v[23] == 1681); + assert_or_panic(v[24] == 1682); + assert_or_panic(v[25] == 1683); + assert_or_panic(v[26] == 1684); + assert_or_panic(v[27] == 1685); + assert_or_panic(v[28] == 1686); + assert_or_panic(v[29] == 1687); + assert_or_panic(v[30] == 1688); + assert_or_panic(v[31] == 1689); + assert_or_panic(v[32] == 1690); + assert_or_panic(v[33] == 1691); + assert_or_panic(v[34] == 1692); + assert_or_panic(v[35] == 1693); + assert_or_panic(v[36] == 1694); + assert_or_panic(v[37] == 1695); + assert_or_panic(v[38] == 1696); + assert_or_panic(v[39] == 1697); + assert_or_panic(v[40] == 1698); + assert_or_panic(v[41] == 1699); + assert_or_panic(v[42] == 1700); + assert_or_panic(v[43] == 1701); + assert_or_panic(v[44] == 1702); + assert_or_panic(v[45] == 1703); + assert_or_panic(v[46] == 1704); + assert_or_panic(v[47] == 1705); + assert_or_panic(v[48] == 1706); + assert_or_panic(v[49] == 1707); + assert_or_panic(v[50] == 1708); + assert_or_panic(v[51] == 1709); + assert_or_panic(v[52] == 1710); + assert_or_panic(v[53] == 1711); + assert_or_panic(v[54] == 1712); + assert_or_panic(v[55] == 1713); + assert_or_panic(v[56] == 1714); + assert_or_panic(v[57] == 1715); + assert_or_panic(v[58] == 1716); + assert_or_panic(v[59] == 1717); + assert_or_panic(v[60] == 1718); + assert_or_panic(v[61] == 1719); + assert_or_panic(v[62] == 1720); + assert_or_panic(v[63] == 1721); + assert_or_panic(v[64] == 1722); + assert_or_panic(v[65] == 1723); + assert_or_panic(v[66] == 1724); + assert_or_panic(v[67] == 1725); + assert_or_panic(v[68] == 1726); + assert_or_panic(v[69] == 1727); + assert_or_panic(v[70] == 1728); + assert_or_panic(v[71] == 1729); + assert_or_panic(v[72] == 1730); + assert_or_panic(v[73] == 1731); + assert_or_panic(v[74] == 1732); + assert_or_panic(v[75] == 1733); + assert_or_panic(v[76] == 1734); + assert_or_panic(v[77] == 1735); + assert_or_panic(v[78] == 1736); + assert_or_panic(v[79] == 1737); + assert_or_panic(v[80] == 1738); + assert_or_panic(v[81] == 1739); + assert_or_panic(v[82] == 1740); + assert_or_panic(v[83] == 1741); + assert_or_panic(v[84] == 1742); + assert_or_panic(v[85] == 1743); + assert_or_panic(v[86] == 1744); + assert_or_panic(v[87] == 1745); + assert_or_panic(v[88] == 1746); + assert_or_panic(v[89] == 1747); + assert_or_panic(v[90] == 1748); + assert_or_panic(v[91] == 1749); + assert_or_panic(v[92] == 1750); + assert_or_panic(v[93] == 1751); + assert_or_panic(v[94] == 1752); + assert_or_panic(v[95] == 1753); + assert_or_panic(v[96] == 1754); + assert_or_panic(v[97] == 1755); + assert_or_panic(v[98] == 1756); + assert_or_panic(v[99] == 1757); + assert_or_panic(v[100] == 1758); + assert_or_panic(v[101] == 1759); + assert_or_panic(v[102] == 1760); + assert_or_panic(v[103] == 1761); + assert_or_panic(v[104] == 1762); + assert_or_panic(v[105] == 1763); + assert_or_panic(v[106] == 1764); + assert_or_panic(v[107] == 1765); + assert_or_panic(v[108] == 1766); + assert_or_panic(v[109] == 1767); + assert_or_panic(v[110] == 1768); + assert_or_panic(v[111] == 1769); + assert_or_panic(v[112] == 1770); + assert_or_panic(v[113] == 1771); + assert_or_panic(v[114] == 1772); + assert_or_panic(v[115] == 1773); + assert_or_panic(v[116] == 1774); + assert_or_panic(v[117] == 1775); + assert_or_panic(v[118] == 1776); + assert_or_panic(v[119] == 1777); + assert_or_panic(v[120] == 1778); + assert_or_panic(v[121] == 1779); + assert_or_panic(v[122] == 1780); + assert_or_panic(v[123] == 1781); + assert_or_panic(v[124] == 1782); + assert_or_panic(v[125] == 1783); + assert_or_panic(v[126] == 1784); + assert_or_panic(v[127] == 1785); + assert_or_panic(i == 128); +} +void c_test_vector_128_u32(void) { + Vector_128_u32 v = zig_ret_vector_128_u32(); + assert_or_panic(v[0] == 1274); + assert_or_panic(v[1] == 1275); + assert_or_panic(v[2] == 1276); + assert_or_panic(v[3] == 1277); + assert_or_panic(v[4] == 1278); + assert_or_panic(v[5] == 1279); + assert_or_panic(v[6] == 1280); + assert_or_panic(v[7] == 1281); + assert_or_panic(v[8] == 1282); + assert_or_panic(v[9] == 1283); + assert_or_panic(v[10] == 1284); + assert_or_panic(v[11] == 1285); + assert_or_panic(v[12] == 1286); + assert_or_panic(v[13] == 1287); + assert_or_panic(v[14] == 1288); + assert_or_panic(v[15] == 1289); + assert_or_panic(v[16] == 1290); + assert_or_panic(v[17] == 1291); + assert_or_panic(v[18] == 1292); + assert_or_panic(v[19] == 1293); + assert_or_panic(v[20] == 1294); + assert_or_panic(v[21] == 1295); + assert_or_panic(v[22] == 1296); + assert_or_panic(v[23] == 1297); + assert_or_panic(v[24] == 1298); + assert_or_panic(v[25] == 1299); + assert_or_panic(v[26] == 1300); + assert_or_panic(v[27] == 1301); + assert_or_panic(v[28] == 1302); + assert_or_panic(v[29] == 1303); + assert_or_panic(v[30] == 1304); + assert_or_panic(v[31] == 1305); + assert_or_panic(v[32] == 1306); + assert_or_panic(v[33] == 1307); + assert_or_panic(v[34] == 1308); + assert_or_panic(v[35] == 1309); + assert_or_panic(v[36] == 1310); + assert_or_panic(v[37] == 1311); + assert_or_panic(v[38] == 1312); + assert_or_panic(v[39] == 1313); + assert_or_panic(v[40] == 1314); + assert_or_panic(v[41] == 1315); + assert_or_panic(v[42] == 1316); + assert_or_panic(v[43] == 1317); + assert_or_panic(v[44] == 1318); + assert_or_panic(v[45] == 1319); + assert_or_panic(v[46] == 1320); + assert_or_panic(v[47] == 1321); + assert_or_panic(v[48] == 1322); + assert_or_panic(v[49] == 1323); + assert_or_panic(v[50] == 1324); + assert_or_panic(v[51] == 1325); + assert_or_panic(v[52] == 1326); + assert_or_panic(v[53] == 1327); + assert_or_panic(v[54] == 1328); + assert_or_panic(v[55] == 1329); + assert_or_panic(v[56] == 1330); + assert_or_panic(v[57] == 1331); + assert_or_panic(v[58] == 1332); + assert_or_panic(v[59] == 1333); + assert_or_panic(v[60] == 1334); + assert_or_panic(v[61] == 1335); + assert_or_panic(v[62] == 1336); + assert_or_panic(v[63] == 1337); + assert_or_panic(v[64] == 1338); + assert_or_panic(v[65] == 1339); + assert_or_panic(v[66] == 1340); + assert_or_panic(v[67] == 1341); + assert_or_panic(v[68] == 1342); + assert_or_panic(v[69] == 1343); + assert_or_panic(v[70] == 1344); + assert_or_panic(v[71] == 1345); + assert_or_panic(v[72] == 1346); + assert_or_panic(v[73] == 1347); + assert_or_panic(v[74] == 1348); + assert_or_panic(v[75] == 1349); + assert_or_panic(v[76] == 1350); + assert_or_panic(v[77] == 1351); + assert_or_panic(v[78] == 1352); + assert_or_panic(v[79] == 1353); + assert_or_panic(v[80] == 1354); + assert_or_panic(v[81] == 1355); + assert_or_panic(v[82] == 1356); + assert_or_panic(v[83] == 1357); + assert_or_panic(v[84] == 1358); + assert_or_panic(v[85] == 1359); + assert_or_panic(v[86] == 1360); + assert_or_panic(v[87] == 1361); + assert_or_panic(v[88] == 1362); + assert_or_panic(v[89] == 1363); + assert_or_panic(v[90] == 1364); + assert_or_panic(v[91] == 1365); + assert_or_panic(v[92] == 1366); + assert_or_panic(v[93] == 1367); + assert_or_panic(v[94] == 1368); + assert_or_panic(v[95] == 1369); + assert_or_panic(v[96] == 1370); + assert_or_panic(v[97] == 1371); + assert_or_panic(v[98] == 1372); + assert_or_panic(v[99] == 1373); + assert_or_panic(v[100] == 1374); + assert_or_panic(v[101] == 1375); + assert_or_panic(v[102] == 1376); + assert_or_panic(v[103] == 1377); + assert_or_panic(v[104] == 1378); + assert_or_panic(v[105] == 1379); + assert_or_panic(v[106] == 1380); + assert_or_panic(v[107] == 1381); + assert_or_panic(v[108] == 1382); + assert_or_panic(v[109] == 1383); + assert_or_panic(v[110] == 1384); + assert_or_panic(v[111] == 1385); + assert_or_panic(v[112] == 1386); + assert_or_panic(v[113] == 1387); + assert_or_panic(v[114] == 1388); + assert_or_panic(v[115] == 1389); + assert_or_panic(v[116] == 1390); + assert_or_panic(v[117] == 1391); + assert_or_panic(v[118] == 1392); + assert_or_panic(v[119] == 1393); + assert_or_panic(v[120] == 1394); + assert_or_panic(v[121] == 1395); + assert_or_panic(v[122] == 1396); + assert_or_panic(v[123] == 1397); + assert_or_panic(v[124] == 1398); + assert_or_panic(v[125] == 1399); + assert_or_panic(v[126] == 1400); + assert_or_panic(v[127] == 1401); + zig_vector_128_u32((Vector_128_u32){ + 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, + 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, + 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, + 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, + 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, + 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, + 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, + 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, + }, 128); +} + +typedef uint64_t Vector_1_u64 __attribute__((vector_size(1 * sizeof(uint64_t)))); + +Vector_1_u64 zig_ret_vector_1_u64(void); +void zig_vector_1_u64(Vector_1_u64, size_t); + +Vector_1_u64 c_ret_vector_1_u64(void) { + return (Vector_1_u64){ 3 }; +} +void c_vector_1_u64(Vector_1_u64 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_u64(void) { + Vector_1_u64 v = zig_ret_vector_1_u64(); + assert_or_panic(v[0] == 1); + zig_vector_1_u64((Vector_1_u64){ 2 }, 1); +} + +typedef uint64_t Vector_2_u64 __attribute__((vector_size(2 * sizeof(uint64_t)))); + +Vector_2_u64 zig_ret_vector_2_u64(void); +void zig_vector_2_u64(Vector_2_u64, size_t); + +Vector_2_u64 c_ret_vector_2_u64(void) { + return (Vector_2_u64){ 9, 10 }; +} +void c_vector_2_u64(Vector_2_u64 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_u64(void) { + Vector_2_u64 v = zig_ret_vector_2_u64(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_u64((Vector_2_u64){ 7, 8 }, 2); +} + +typedef uint64_t Vector_3_u64 __attribute__((vector_size(3 * sizeof(uint64_t)))); + +Vector_3_u64 zig_ret_vector_3_u64(void); +void zig_vector_3_u64(Vector_3_u64, size_t); + +Vector_3_u64 c_ret_vector_3_u64(void) { + return (Vector_3_u64){ 19, 20, 21 }; +} +void c_vector_3_u64(Vector_3_u64 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 3); +} +void c_test_vector_3_u64(void) { + Vector_3_u64 v = zig_ret_vector_3_u64(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_u64((Vector_3_u64){ 16, 17, 18 }, 3); +} + +typedef uint64_t Vector_4_u64 __attribute__((vector_size(4 * sizeof(uint64_t)))); + +Vector_4_u64 zig_ret_vector_4_u64(void); +void zig_vector_4_u64(Vector_4_u64, size_t); + +Vector_4_u64 c_ret_vector_4_u64(void) { + return (Vector_4_u64){ 33, 34, 35, 36 }; +} +void c_vector_4_u64(Vector_4_u64 v, size_t i) { + assert_or_panic(v[0] == 37); + assert_or_panic(v[1] == 38); + assert_or_panic(v[2] == 39); + assert_or_panic(v[3] == 40); + assert_or_panic(i == 4); +} +void c_test_vector_4_u64(void) { + Vector_4_u64 v = zig_ret_vector_4_u64(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_u64((Vector_4_u64){ 29, 30, 31, 32 }, 4); +} + +typedef uint64_t Vector_6_u64 __attribute__((vector_size(6 * sizeof(uint64_t)))); + +Vector_6_u64 zig_ret_vector_6_u64(void); +void zig_vector_6_u64(Vector_6_u64, size_t); + +Vector_6_u64 c_ret_vector_6_u64(void) { + return (Vector_6_u64){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_u64(Vector_6_u64 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_u64(void) { + Vector_6_u64 v = zig_ret_vector_6_u64(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_u64((Vector_6_u64){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef uint64_t Vector_8_u64 __attribute__((vector_size(8 * sizeof(uint64_t)))); + +Vector_8_u64 zig_ret_vector_8_u64(void); +void zig_vector_8_u64(Vector_8_u64, size_t); + +Vector_8_u64 c_ret_vector_8_u64(void) { + return (Vector_8_u64){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_u64(Vector_8_u64 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_u64(void) { + Vector_8_u64 v = zig_ret_vector_8_u64(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_u64((Vector_8_u64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef uint64_t Vector_12_u64 __attribute__((vector_size(12 * sizeof(uint64_t)))); + +Vector_12_u64 zig_ret_vector_12_u64(void); +void zig_vector_12_u64(Vector_12_u64, size_t); + +Vector_12_u64 c_ret_vector_12_u64(void) { + return (Vector_12_u64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 }; +} +void c_vector_12_u64(Vector_12_u64 v, size_t i) { + assert_or_panic(v[0] == 133); + assert_or_panic(v[1] == 134); + assert_or_panic(v[2] == 135); + assert_or_panic(v[3] == 136); + assert_or_panic(v[4] == 137); + assert_or_panic(v[5] == 138); + assert_or_panic(v[6] == 139); + assert_or_panic(v[7] == 140); + assert_or_panic(v[8] == 141); + assert_or_panic(v[9] == 142); + assert_or_panic(v[10] == 143); + assert_or_panic(v[11] == 144); + assert_or_panic(i == 12); +} +void c_test_vector_12_u64(void) { + Vector_12_u64 v = zig_ret_vector_12_u64(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 100); + assert_or_panic(v[4] == 101); + assert_or_panic(v[5] == 102); + assert_or_panic(v[6] == 103); + assert_or_panic(v[7] == 104); + assert_or_panic(v[8] == 105); + assert_or_panic(v[9] == 106); + assert_or_panic(v[10] == 107); + assert_or_panic(v[11] == 108); + zig_vector_12_u64((Vector_12_u64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12); +} + +typedef uint64_t Vector_16_u64 __attribute__((vector_size(16 * sizeof(uint64_t)))); + +Vector_16_u64 zig_ret_vector_16_u64(void); +void zig_vector_16_u64(Vector_16_u64, size_t); + +Vector_16_u64 c_ret_vector_16_u64(void) { + return (Vector_16_u64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 }; +} +void c_vector_16_u64(Vector_16_u64 v, size_t i) { + assert_or_panic(v[0] == 193); + assert_or_panic(v[1] == 194); + assert_or_panic(v[2] == 195); + assert_or_panic(v[3] == 196); + assert_or_panic(v[4] == 197); + assert_or_panic(v[5] == 198); + assert_or_panic(v[6] == 199); + assert_or_panic(v[7] == 200); + assert_or_panic(v[8] == 201); + assert_or_panic(v[9] == 202); + assert_or_panic(v[10] == 203); + assert_or_panic(v[11] == 204); + assert_or_panic(v[12] == 205); + assert_or_panic(v[13] == 206); + assert_or_panic(v[14] == 207); + assert_or_panic(v[15] == 208); + assert_or_panic(i == 16); +} +void c_test_vector_16_u64(void) { + Vector_16_u64 v = zig_ret_vector_16_u64(); + assert_or_panic(v[0] == 145); + assert_or_panic(v[1] == 146); + assert_or_panic(v[2] == 147); + assert_or_panic(v[3] == 148); + assert_or_panic(v[4] == 149); + assert_or_panic(v[5] == 150); + assert_or_panic(v[6] == 151); + assert_or_panic(v[7] == 152); + assert_or_panic(v[8] == 153); + assert_or_panic(v[9] == 154); + assert_or_panic(v[10] == 155); + assert_or_panic(v[11] == 156); + assert_or_panic(v[12] == 157); + assert_or_panic(v[13] == 158); + assert_or_panic(v[14] == 159); + assert_or_panic(v[15] == 160); + zig_vector_16_u64((Vector_16_u64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16); +} + +typedef uint64_t Vector_24_u64 __attribute__((vector_size(24 * sizeof(uint64_t)))); + +Vector_24_u64 zig_ret_vector_24_u64(void); +void zig_vector_24_u64(Vector_24_u64, size_t); + +Vector_24_u64 c_ret_vector_24_u64(void) { + return (Vector_24_u64){ + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, + }; +} +void c_vector_24_u64(Vector_24_u64 v, size_t i) { + assert_or_panic(v[0] == 281); + assert_or_panic(v[1] == 282); + assert_or_panic(v[2] == 283); + assert_or_panic(v[3] == 284); + assert_or_panic(v[4] == 285); + assert_or_panic(v[5] == 286); + assert_or_panic(v[6] == 287); + assert_or_panic(v[7] == 288); + assert_or_panic(v[8] == 289); + assert_or_panic(v[9] == 290); + assert_or_panic(v[10] == 291); + assert_or_panic(v[11] == 292); + assert_or_panic(v[12] == 293); + assert_or_panic(v[13] == 294); + assert_or_panic(v[14] == 295); + assert_or_panic(v[15] == 296); + assert_or_panic(v[16] == 297); + assert_or_panic(v[17] == 298); + assert_or_panic(v[18] == 299); + assert_or_panic(v[19] == 300); + assert_or_panic(v[20] == 301); + assert_or_panic(v[21] == 302); + assert_or_panic(v[22] == 303); + assert_or_panic(v[23] == 304); + assert_or_panic(i == 24); +} +void c_test_vector_24_u64(void) { + Vector_24_u64 v = zig_ret_vector_24_u64(); + assert_or_panic(v[0] == 209); + assert_or_panic(v[1] == 210); + assert_or_panic(v[2] == 211); + assert_or_panic(v[3] == 212); + assert_or_panic(v[4] == 213); + assert_or_panic(v[5] == 214); + assert_or_panic(v[6] == 215); + assert_or_panic(v[7] == 216); + assert_or_panic(v[8] == 217); + assert_or_panic(v[9] == 218); + assert_or_panic(v[10] == 219); + assert_or_panic(v[11] == 220); + assert_or_panic(v[12] == 221); + assert_or_panic(v[13] == 222); + assert_or_panic(v[14] == 223); + assert_or_panic(v[15] == 224); + assert_or_panic(v[16] == 225); + assert_or_panic(v[17] == 226); + assert_or_panic(v[18] == 227); + assert_or_panic(v[19] == 228); + assert_or_panic(v[20] == 229); + assert_or_panic(v[21] == 230); + assert_or_panic(v[22] == 231); + assert_or_panic(v[23] == 232); + zig_vector_24_u64((Vector_24_u64){ + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, + }, 24); +} + +typedef uint64_t Vector_32_u64 __attribute__((vector_size(32 * sizeof(uint64_t)))); + +Vector_32_u64 zig_ret_vector_32_u64(void); +void zig_vector_32_u64(Vector_32_u64, size_t); + +Vector_32_u64 c_ret_vector_32_u64(void) { + return (Vector_32_u64){ + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + }; +} +void c_vector_32_u64(Vector_32_u64 v, size_t i) { + assert_or_panic(v[0] == 401); + assert_or_panic(v[1] == 402); + assert_or_panic(v[2] == 403); + assert_or_panic(v[3] == 404); + assert_or_panic(v[4] == 405); + assert_or_panic(v[5] == 406); + assert_or_panic(v[6] == 407); + assert_or_panic(v[7] == 408); + assert_or_panic(v[8] == 409); + assert_or_panic(v[9] == 410); + assert_or_panic(v[10] == 411); + assert_or_panic(v[11] == 412); + assert_or_panic(v[12] == 413); + assert_or_panic(v[13] == 414); + assert_or_panic(v[14] == 415); + assert_or_panic(v[15] == 416); + assert_or_panic(v[16] == 417); + assert_or_panic(v[17] == 418); + assert_or_panic(v[18] == 419); + assert_or_panic(v[19] == 420); + assert_or_panic(v[20] == 421); + assert_or_panic(v[21] == 422); + assert_or_panic(v[22] == 423); + assert_or_panic(v[23] == 424); + assert_or_panic(v[24] == 425); + assert_or_panic(v[25] == 426); + assert_or_panic(v[26] == 427); + assert_or_panic(v[27] == 428); + assert_or_panic(v[28] == 429); + assert_or_panic(v[29] == 430); + assert_or_panic(v[30] == 431); + assert_or_panic(v[31] == 432); + assert_or_panic(i == 32); +} +void c_test_vector_32_u64(void) { + Vector_32_u64 v = zig_ret_vector_32_u64(); + assert_or_panic(v[0] == 305); + assert_or_panic(v[1] == 306); + assert_or_panic(v[2] == 307); + assert_or_panic(v[3] == 308); + assert_or_panic(v[4] == 309); + assert_or_panic(v[5] == 310); + assert_or_panic(v[6] == 311); + assert_or_panic(v[7] == 312); + assert_or_panic(v[8] == 313); + assert_or_panic(v[9] == 314); + assert_or_panic(v[10] == 315); + assert_or_panic(v[11] == 316); + assert_or_panic(v[12] == 317); + assert_or_panic(v[13] == 318); + assert_or_panic(v[14] == 319); + assert_or_panic(v[15] == 320); + assert_or_panic(v[16] == 321); + assert_or_panic(v[17] == 322); + assert_or_panic(v[18] == 323); + assert_or_panic(v[19] == 324); + assert_or_panic(v[20] == 325); + assert_or_panic(v[21] == 326); + assert_or_panic(v[22] == 327); + assert_or_panic(v[23] == 328); + assert_or_panic(v[24] == 329); + assert_or_panic(v[25] == 330); + assert_or_panic(v[26] == 331); + assert_or_panic(v[27] == 332); + assert_or_panic(v[28] == 333); + assert_or_panic(v[29] == 334); + assert_or_panic(v[30] == 335); + assert_or_panic(v[31] == 336); + zig_vector_32_u64((Vector_32_u64){ + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + }, 32); +} + +typedef uint64_t Vector_48_u64 __attribute__((vector_size(48 * sizeof(uint64_t)))); + +Vector_48_u64 zig_ret_vector_48_u64(void); +void zig_vector_48_u64(Vector_48_u64, size_t); + +Vector_48_u64 c_ret_vector_48_u64(void) { + return (Vector_48_u64){ + 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, + }; +} +void c_vector_48_u64(Vector_48_u64 v, size_t i) { + assert_or_panic(v[0] == 577); + assert_or_panic(v[1] == 578); + assert_or_panic(v[2] == 579); + assert_or_panic(v[3] == 580); + assert_or_panic(v[4] == 581); + assert_or_panic(v[5] == 582); + assert_or_panic(v[6] == 583); + assert_or_panic(v[7] == 584); + assert_or_panic(v[8] == 585); + assert_or_panic(v[9] == 586); + assert_or_panic(v[10] == 587); + assert_or_panic(v[11] == 588); + assert_or_panic(v[12] == 589); + assert_or_panic(v[13] == 590); + assert_or_panic(v[14] == 591); + assert_or_panic(v[15] == 592); + assert_or_panic(v[16] == 593); + assert_or_panic(v[17] == 594); + assert_or_panic(v[18] == 595); + assert_or_panic(v[19] == 596); + assert_or_panic(v[20] == 597); + assert_or_panic(v[21] == 598); + assert_or_panic(v[22] == 599); + assert_or_panic(v[23] == 600); + assert_or_panic(v[24] == 601); + assert_or_panic(v[25] == 602); + assert_or_panic(v[26] == 603); + assert_or_panic(v[27] == 604); + assert_or_panic(v[28] == 605); + assert_or_panic(v[29] == 606); + assert_or_panic(v[30] == 607); + assert_or_panic(v[31] == 608); + assert_or_panic(v[32] == 609); + assert_or_panic(v[33] == 610); + assert_or_panic(v[34] == 611); + assert_or_panic(v[35] == 612); + assert_or_panic(v[36] == 613); + assert_or_panic(v[37] == 614); + assert_or_panic(v[38] == 615); + assert_or_panic(v[39] == 616); + assert_or_panic(v[40] == 617); + assert_or_panic(v[41] == 618); + assert_or_panic(v[42] == 619); + assert_or_panic(v[43] == 620); + assert_or_panic(v[44] == 621); + assert_or_panic(v[45] == 622); + assert_or_panic(v[46] == 623); + assert_or_panic(v[47] == 624); + assert_or_panic(i == 48); +} +void c_test_vector_48_u64(void) { + Vector_48_u64 v = zig_ret_vector_48_u64(); + assert_or_panic(v[0] == 433); + assert_or_panic(v[1] == 434); + assert_or_panic(v[2] == 435); + assert_or_panic(v[3] == 436); + assert_or_panic(v[4] == 437); + assert_or_panic(v[5] == 438); + assert_or_panic(v[6] == 439); + assert_or_panic(v[7] == 440); + assert_or_panic(v[8] == 441); + assert_or_panic(v[9] == 442); + assert_or_panic(v[10] == 443); + assert_or_panic(v[11] == 444); + assert_or_panic(v[12] == 445); + assert_or_panic(v[13] == 446); + assert_or_panic(v[14] == 447); + assert_or_panic(v[15] == 448); + assert_or_panic(v[16] == 449); + assert_or_panic(v[17] == 450); + assert_or_panic(v[18] == 451); + assert_or_panic(v[19] == 452); + assert_or_panic(v[20] == 453); + assert_or_panic(v[21] == 454); + assert_or_panic(v[22] == 455); + assert_or_panic(v[23] == 456); + assert_or_panic(v[24] == 457); + assert_or_panic(v[25] == 458); + assert_or_panic(v[26] == 459); + assert_or_panic(v[27] == 460); + assert_or_panic(v[28] == 461); + assert_or_panic(v[29] == 462); + assert_or_panic(v[30] == 463); + assert_or_panic(v[31] == 464); + assert_or_panic(v[32] == 465); + assert_or_panic(v[33] == 466); + assert_or_panic(v[34] == 467); + assert_or_panic(v[35] == 468); + assert_or_panic(v[36] == 469); + assert_or_panic(v[37] == 470); + assert_or_panic(v[38] == 471); + assert_or_panic(v[39] == 472); + assert_or_panic(v[40] == 473); + assert_or_panic(v[41] == 474); + assert_or_panic(v[42] == 475); + assert_or_panic(v[43] == 476); + assert_or_panic(v[44] == 477); + assert_or_panic(v[45] == 478); + assert_or_panic(v[46] == 479); + assert_or_panic(v[47] == 480); + zig_vector_48_u64((Vector_48_u64){ + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + }, 48); +} + +typedef uint64_t Vector_64_u64 __attribute__((vector_size(64 * sizeof(uint64_t)))); + +Vector_64_u64 zig_ret_vector_64_u64(void); +void zig_vector_64_u64(Vector_64_u64, size_t); + +Vector_64_u64 c_ret_vector_64_u64(void) { + return (Vector_64_u64){ + 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, + 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, + }; +} +void c_vector_64_u64(Vector_64_u64 v, size_t i) { + assert_or_panic(v[0] == 817); + assert_or_panic(v[1] == 818); + assert_or_panic(v[2] == 819); + assert_or_panic(v[3] == 820); + assert_or_panic(v[4] == 821); + assert_or_panic(v[5] == 822); + assert_or_panic(v[6] == 823); + assert_or_panic(v[7] == 824); + assert_or_panic(v[8] == 825); + assert_or_panic(v[9] == 826); + assert_or_panic(v[10] == 827); + assert_or_panic(v[11] == 828); + assert_or_panic(v[12] == 829); + assert_or_panic(v[13] == 830); + assert_or_panic(v[14] == 831); + assert_or_panic(v[15] == 832); + assert_or_panic(v[16] == 833); + assert_or_panic(v[17] == 834); + assert_or_panic(v[18] == 835); + assert_or_panic(v[19] == 836); + assert_or_panic(v[20] == 837); + assert_or_panic(v[21] == 838); + assert_or_panic(v[22] == 839); + assert_or_panic(v[23] == 840); + assert_or_panic(v[24] == 841); + assert_or_panic(v[25] == 842); + assert_or_panic(v[26] == 843); + assert_or_panic(v[27] == 844); + assert_or_panic(v[28] == 845); + assert_or_panic(v[29] == 846); + assert_or_panic(v[30] == 847); + assert_or_panic(v[31] == 848); + assert_or_panic(v[32] == 849); + assert_or_panic(v[33] == 850); + assert_or_panic(v[34] == 851); + assert_or_panic(v[35] == 852); + assert_or_panic(v[36] == 853); + assert_or_panic(v[37] == 854); + assert_or_panic(v[38] == 855); + assert_or_panic(v[39] == 856); + assert_or_panic(v[40] == 857); + assert_or_panic(v[41] == 858); + assert_or_panic(v[42] == 859); + assert_or_panic(v[43] == 860); + assert_or_panic(v[44] == 861); + assert_or_panic(v[45] == 862); + assert_or_panic(v[46] == 863); + assert_or_panic(v[47] == 864); + assert_or_panic(v[48] == 865); + assert_or_panic(v[49] == 866); + assert_or_panic(v[50] == 867); + assert_or_panic(v[51] == 868); + assert_or_panic(v[52] == 869); + assert_or_panic(v[53] == 870); + assert_or_panic(v[54] == 871); + assert_or_panic(v[55] == 872); + assert_or_panic(v[56] == 873); + assert_or_panic(v[57] == 874); + assert_or_panic(v[58] == 875); + assert_or_panic(v[59] == 876); + assert_or_panic(v[60] == 877); + assert_or_panic(v[61] == 878); + assert_or_panic(v[62] == 879); + assert_or_panic(v[63] == 880); + assert_or_panic(i == 64); +} +void c_test_vector_64_u64(void) { + Vector_64_u64 v = zig_ret_vector_64_u64(); + assert_or_panic(v[0] == 625); + assert_or_panic(v[1] == 626); + assert_or_panic(v[2] == 627); + assert_or_panic(v[3] == 628); + assert_or_panic(v[4] == 629); + assert_or_panic(v[5] == 630); + assert_or_panic(v[6] == 631); + assert_or_panic(v[7] == 632); + assert_or_panic(v[8] == 633); + assert_or_panic(v[9] == 634); + assert_or_panic(v[10] == 635); + assert_or_panic(v[11] == 636); + assert_or_panic(v[12] == 637); + assert_or_panic(v[13] == 638); + assert_or_panic(v[14] == 639); + assert_or_panic(v[15] == 640); + assert_or_panic(v[16] == 641); + assert_or_panic(v[17] == 642); + assert_or_panic(v[18] == 643); + assert_or_panic(v[19] == 644); + assert_or_panic(v[20] == 645); + assert_or_panic(v[21] == 646); + assert_or_panic(v[22] == 647); + assert_or_panic(v[23] == 648); + assert_or_panic(v[24] == 649); + assert_or_panic(v[25] == 650); + assert_or_panic(v[26] == 651); + assert_or_panic(v[27] == 652); + assert_or_panic(v[28] == 653); + assert_or_panic(v[29] == 654); + assert_or_panic(v[30] == 655); + assert_or_panic(v[31] == 656); + assert_or_panic(v[32] == 657); + assert_or_panic(v[33] == 658); + assert_or_panic(v[34] == 659); + assert_or_panic(v[35] == 660); + assert_or_panic(v[36] == 661); + assert_or_panic(v[37] == 662); + assert_or_panic(v[38] == 663); + assert_or_panic(v[39] == 664); + assert_or_panic(v[40] == 665); + assert_or_panic(v[41] == 666); + assert_or_panic(v[42] == 667); + assert_or_panic(v[43] == 668); + assert_or_panic(v[44] == 669); + assert_or_panic(v[45] == 670); + assert_or_panic(v[46] == 671); + assert_or_panic(v[47] == 672); + assert_or_panic(v[48] == 673); + assert_or_panic(v[49] == 674); + assert_or_panic(v[50] == 675); + assert_or_panic(v[51] == 676); + assert_or_panic(v[52] == 677); + assert_or_panic(v[53] == 678); + assert_or_panic(v[54] == 679); + assert_or_panic(v[55] == 680); + assert_or_panic(v[56] == 681); + assert_or_panic(v[57] == 682); + assert_or_panic(v[58] == 683); + assert_or_panic(v[59] == 684); + assert_or_panic(v[60] == 685); + assert_or_panic(v[61] == 686); + assert_or_panic(v[62] == 687); + assert_or_panic(v[63] == 688); + zig_vector_64_u64((Vector_64_u64){ + 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, + 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, + }, 64); +} + +typedef float Vector_1_f32 __attribute__((vector_size(1 * sizeof(float)))); + +Vector_1_f32 zig_ret_vector_1_f32(void); +void zig_vector_1_f32(Vector_1_f32, size_t); + +Vector_1_f32 c_ret_vector_1_f32(void) { + return (Vector_1_f32){ 3 }; +} +void c_vector_1_f32(Vector_1_f32 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_f32(void) { + Vector_1_f32 v = zig_ret_vector_1_f32(); + assert_or_panic(v[0] == 1); + zig_vector_1_f32((Vector_1_f32){ 2 }, 1); +} + +typedef float Vector_2_f32 __attribute__((vector_size(2 * sizeof(float)))); + +Vector_2_f32 zig_ret_vector_2_f32(void); +void zig_vector_2_f32(Vector_2_f32, size_t); + +Vector_2_f32 c_ret_vector_2_f32(void) { + return (Vector_2_f32){ 9, 10 }; +} +void c_vector_2_f32(Vector_2_f32 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_f32(void) { + Vector_2_f32 v = zig_ret_vector_2_f32(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_f32((Vector_2_f32){ 7, 8 }, 2); +} + +typedef float Vector_3_f32 __attribute__((vector_size(3 * sizeof(float)))); + +Vector_3_f32 zig_ret_vector_3_f32(void); +void zig_vector_3_f32(Vector_3_f32, size_t); + +Vector_3_f32 c_ret_vector_3_f32(void) { + return (Vector_3_f32){ 19, 20, 21 }; +} +void c_vector_3_f32(Vector_3_f32 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 32); +} +void c_test_vector_3_f32(void) { + Vector_3_f32 v = zig_ret_vector_3_f32(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_f32((Vector_3_f32){ 16, 17, 18 }, 3); +} + +typedef float Vector_4_f32 __attribute__((vector_size(4 * sizeof(float)))); + +Vector_4_f32 zig_ret_vector_4_f32(void); +void zig_vector_4_f32(Vector_4_f32, size_t); +void zig_vector_4_f32_vector_4_f32(Vector_4_f32, Vector_4_f32, size_t); + +Vector_4_f32 c_ret_vector_4_f32(void) { + return (Vector_4_f32){ 41, 42, 43, 44 }; +} +void c_vector_4_f32(Vector_4_f32 v, size_t i) { + assert_or_panic(v[0] == 45); + assert_or_panic(v[1] == 46); + assert_or_panic(v[2] == 47); + assert_or_panic(v[3] == 48); + assert_or_panic(i == 4); +} +void c_vector_4_f32_vector_4_f32(Vector_4_f32 v0, Vector_4_f32 v1, size_t i) { + assert_or_panic(v0[0] == 49); + assert_or_panic(v0[1] == 50); + assert_or_panic(v0[2] == 51); + assert_or_panic(v0[3] == 52); + assert_or_panic(v1[0] == 53); + assert_or_panic(v1[1] == 54); + assert_or_panic(v1[2] == 55); + assert_or_panic(v1[3] == 56); + assert_or_panic(i == 8); +} +void c_test_vector_4_f32(void) { + Vector_4_f32 v = zig_ret_vector_4_f32(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_f32((Vector_4_f32){ 29, 30, 31, 32 }, 4); + zig_vector_4_f32_vector_4_f32((Vector_4_f32){ 33, 34, 35, 36 }, (Vector_4_f32){ 37, 38, 39, 40 }, 8); +} + +typedef float Vector_6_f32 __attribute__((vector_size(6 * sizeof(float)))); + +Vector_6_f32 zig_ret_vector_6_f32(void); +void zig_vector_6_f32(Vector_6_f32, size_t); + +Vector_6_f32 c_ret_vector_6_f32(void) { + return (Vector_6_f32){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_f32(Vector_6_f32 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_f32(void) { + Vector_6_f32 v = zig_ret_vector_6_f32(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_f32((Vector_6_f32){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef float Vector_8_f32 __attribute__((vector_size(8 * sizeof(float)))); + +Vector_8_f32 zig_ret_vector_8_f32(void); +void zig_vector_8_f32(Vector_8_f32, size_t); + +Vector_8_f32 c_ret_vector_8_f32(void) { + return (Vector_8_f32){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_f32(Vector_8_f32 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_f32(void) { + Vector_8_f32 v = zig_ret_vector_8_f32(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_f32((Vector_8_f32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef float Vector_12_f32 __attribute__((vector_size(12 * sizeof(float)))); + +Vector_12_f32 zig_ret_vector_12_f32(void); +void zig_vector_12_f32(Vector_12_f32, size_t); + +Vector_12_f32 c_ret_vector_12_f32(void) { + return (Vector_12_f32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 }; +} +void c_vector_12_f32(Vector_12_f32 v, size_t i) { + assert_or_panic(v[0] == 133); + assert_or_panic(v[1] == 134); + assert_or_panic(v[2] == 135); + assert_or_panic(v[3] == 136); + assert_or_panic(v[4] == 137); + assert_or_panic(v[5] == 138); + assert_or_panic(v[6] == 139); + assert_or_panic(v[7] == 140); + assert_or_panic(v[8] == 141); + assert_or_panic(v[9] == 142); + assert_or_panic(v[10] == 143); + assert_or_panic(v[11] == 144); + assert_or_panic(i == 12); +} +void c_test_vector_12_f32(void) { + Vector_12_f32 v = zig_ret_vector_12_f32(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 100); + assert_or_panic(v[4] == 101); + assert_or_panic(v[5] == 102); + assert_or_panic(v[6] == 103); + assert_or_panic(v[7] == 104); + assert_or_panic(v[8] == 105); + assert_or_panic(v[9] == 106); + assert_or_panic(v[10] == 107); + assert_or_panic(v[11] == 108); + zig_vector_12_f32((Vector_12_f32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12); +} + +typedef float Vector_16_f32 __attribute__((vector_size(16 * sizeof(float)))); + +Vector_16_f32 zig_ret_vector_16_f32(void); +void zig_vector_16_f32(Vector_16_f32, size_t); + +Vector_16_f32 c_ret_vector_16_f32(void) { + return (Vector_16_f32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 }; +} +void c_vector_16_f32(Vector_16_f32 v, size_t i) { + assert_or_panic(v[0] == 193); + assert_or_panic(v[1] == 194); + assert_or_panic(v[2] == 195); + assert_or_panic(v[3] == 196); + assert_or_panic(v[4] == 197); + assert_or_panic(v[5] == 198); + assert_or_panic(v[6] == 199); + assert_or_panic(v[7] == 200); + assert_or_panic(v[8] == 201); + assert_or_panic(v[9] == 202); + assert_or_panic(v[10] == 203); + assert_or_panic(v[11] == 204); + assert_or_panic(v[12] == 205); + assert_or_panic(v[13] == 206); + assert_or_panic(v[14] == 207); + assert_or_panic(v[15] == 208); + assert_or_panic(i == 16); +} +void c_test_vector_16_f32(void) { + Vector_16_f32 v = zig_ret_vector_16_f32(); + assert_or_panic(v[0] == 145); + assert_or_panic(v[1] == 146); + assert_or_panic(v[2] == 147); + assert_or_panic(v[3] == 148); + assert_or_panic(v[4] == 149); + assert_or_panic(v[5] == 150); + assert_or_panic(v[6] == 151); + assert_or_panic(v[7] == 152); + assert_or_panic(v[8] == 153); + assert_or_panic(v[9] == 154); + assert_or_panic(v[10] == 155); + assert_or_panic(v[11] == 156); + assert_or_panic(v[12] == 157); + assert_or_panic(v[13] == 158); + assert_or_panic(v[14] == 159); + assert_or_panic(v[15] == 160); + zig_vector_16_f32((Vector_16_f32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16); +} + +typedef float Vector_24_f32 __attribute__((vector_size(24 * sizeof(float)))); + +Vector_24_f32 zig_ret_vector_24_f32(void); +void zig_vector_24_f32(Vector_24_f32, size_t); + +Vector_24_f32 c_ret_vector_24_f32(void) { + return (Vector_24_f32){ + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, + }; +} +void c_vector_24_f32(Vector_24_f32 v, size_t i) { + assert_or_panic(v[0] == 281); + assert_or_panic(v[1] == 282); + assert_or_panic(v[2] == 283); + assert_or_panic(v[3] == 284); + assert_or_panic(v[4] == 285); + assert_or_panic(v[5] == 286); + assert_or_panic(v[6] == 287); + assert_or_panic(v[7] == 288); + assert_or_panic(v[8] == 289); + assert_or_panic(v[9] == 290); + assert_or_panic(v[10] == 291); + assert_or_panic(v[11] == 292); + assert_or_panic(v[12] == 293); + assert_or_panic(v[13] == 294); + assert_or_panic(v[14] == 295); + assert_or_panic(v[15] == 296); + assert_or_panic(v[16] == 297); + assert_or_panic(v[17] == 298); + assert_or_panic(v[18] == 299); + assert_or_panic(v[19] == 300); + assert_or_panic(v[20] == 301); + assert_or_panic(v[21] == 302); + assert_or_panic(v[22] == 303); + assert_or_panic(v[23] == 304); + assert_or_panic(i == 24); +} +void c_test_vector_24_f32(void) { + Vector_24_f32 v = zig_ret_vector_24_f32(); + assert_or_panic(v[0] == 209); + assert_or_panic(v[1] == 210); + assert_or_panic(v[2] == 211); + assert_or_panic(v[3] == 212); + assert_or_panic(v[4] == 213); + assert_or_panic(v[5] == 214); + assert_or_panic(v[6] == 215); + assert_or_panic(v[7] == 216); + assert_or_panic(v[8] == 217); + assert_or_panic(v[9] == 218); + assert_or_panic(v[10] == 219); + assert_or_panic(v[11] == 220); + assert_or_panic(v[12] == 221); + assert_or_panic(v[13] == 222); + assert_or_panic(v[14] == 223); + assert_or_panic(v[15] == 224); + assert_or_panic(v[16] == 225); + assert_or_panic(v[17] == 226); + assert_or_panic(v[18] == 227); + assert_or_panic(v[19] == 228); + assert_or_panic(v[20] == 229); + assert_or_panic(v[21] == 230); + assert_or_panic(v[22] == 231); + assert_or_panic(v[23] == 232); + zig_vector_24_f32((Vector_24_f32){ + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, + }, 24); +} + +typedef float Vector_32_f32 __attribute__((vector_size(32 * sizeof(float)))); + +Vector_32_f32 zig_ret_vector_32_f32(void); +void zig_vector_32_f32(Vector_32_f32, size_t); + +Vector_32_f32 c_ret_vector_32_f32(void) { + return (Vector_32_f32){ + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + }; +} +void c_vector_32_f32(Vector_32_f32 v, size_t i) { + assert_or_panic(v[0] == 401); + assert_or_panic(v[1] == 402); + assert_or_panic(v[2] == 403); + assert_or_panic(v[3] == 404); + assert_or_panic(v[4] == 405); + assert_or_panic(v[5] == 406); + assert_or_panic(v[6] == 407); + assert_or_panic(v[7] == 408); + assert_or_panic(v[8] == 409); + assert_or_panic(v[9] == 410); + assert_or_panic(v[10] == 411); + assert_or_panic(v[11] == 412); + assert_or_panic(v[12] == 413); + assert_or_panic(v[13] == 414); + assert_or_panic(v[14] == 415); + assert_or_panic(v[15] == 416); + assert_or_panic(v[16] == 417); + assert_or_panic(v[17] == 418); + assert_or_panic(v[18] == 419); + assert_or_panic(v[19] == 420); + assert_or_panic(v[20] == 421); + assert_or_panic(v[21] == 422); + assert_or_panic(v[22] == 423); + assert_or_panic(v[23] == 424); + assert_or_panic(v[24] == 425); + assert_or_panic(v[25] == 426); + assert_or_panic(v[26] == 427); + assert_or_panic(v[27] == 428); + assert_or_panic(v[28] == 429); + assert_or_panic(v[29] == 430); + assert_or_panic(v[30] == 431); + assert_or_panic(v[31] == 432); + assert_or_panic(i == 32); +} +void c_test_vector_32_f32(void) { + Vector_32_f32 v = zig_ret_vector_32_f32(); + assert_or_panic(v[0] == 305); + assert_or_panic(v[1] == 306); + assert_or_panic(v[2] == 307); + assert_or_panic(v[3] == 308); + assert_or_panic(v[4] == 309); + assert_or_panic(v[5] == 310); + assert_or_panic(v[6] == 311); + assert_or_panic(v[7] == 312); + assert_or_panic(v[8] == 313); + assert_or_panic(v[9] == 314); + assert_or_panic(v[10] == 315); + assert_or_panic(v[11] == 316); + assert_or_panic(v[12] == 317); + assert_or_panic(v[13] == 318); + assert_or_panic(v[14] == 319); + assert_or_panic(v[15] == 320); + assert_or_panic(v[16] == 321); + assert_or_panic(v[17] == 322); + assert_or_panic(v[18] == 323); + assert_or_panic(v[19] == 324); + assert_or_panic(v[20] == 325); + assert_or_panic(v[21] == 326); + assert_or_panic(v[22] == 327); + assert_or_panic(v[23] == 328); + assert_or_panic(v[24] == 329); + assert_or_panic(v[25] == 330); + assert_or_panic(v[26] == 331); + assert_or_panic(v[27] == 332); + assert_or_panic(v[28] == 333); + assert_or_panic(v[29] == 334); + assert_or_panic(v[30] == 335); + assert_or_panic(v[31] == 336); + zig_vector_32_f32((Vector_32_f32){ + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + }, 32); +} + +typedef float Vector_48_f32 __attribute__((vector_size(48 * sizeof(float)))); + +Vector_48_f32 zig_ret_vector_48_f32(void); +void zig_vector_48_f32(Vector_48_f32, size_t); + +Vector_48_f32 c_ret_vector_48_f32(void) { + return (Vector_48_f32){ + 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, + }; +} +void c_vector_48_f32(Vector_48_f32 v, size_t i) { + assert_or_panic(v[0] == 577); + assert_or_panic(v[1] == 578); + assert_or_panic(v[2] == 579); + assert_or_panic(v[3] == 580); + assert_or_panic(v[4] == 581); + assert_or_panic(v[5] == 582); + assert_or_panic(v[6] == 583); + assert_or_panic(v[7] == 584); + assert_or_panic(v[8] == 585); + assert_or_panic(v[9] == 586); + assert_or_panic(v[10] == 587); + assert_or_panic(v[11] == 588); + assert_or_panic(v[12] == 589); + assert_or_panic(v[13] == 590); + assert_or_panic(v[14] == 591); + assert_or_panic(v[15] == 592); + assert_or_panic(v[16] == 593); + assert_or_panic(v[17] == 594); + assert_or_panic(v[18] == 595); + assert_or_panic(v[19] == 596); + assert_or_panic(v[20] == 597); + assert_or_panic(v[21] == 598); + assert_or_panic(v[22] == 599); + assert_or_panic(v[23] == 600); + assert_or_panic(v[24] == 601); + assert_or_panic(v[25] == 602); + assert_or_panic(v[26] == 603); + assert_or_panic(v[27] == 604); + assert_or_panic(v[28] == 605); + assert_or_panic(v[29] == 606); + assert_or_panic(v[30] == 607); + assert_or_panic(v[31] == 608); + assert_or_panic(v[32] == 609); + assert_or_panic(v[33] == 610); + assert_or_panic(v[34] == 611); + assert_or_panic(v[35] == 612); + assert_or_panic(v[36] == 613); + assert_or_panic(v[37] == 614); + assert_or_panic(v[38] == 615); + assert_or_panic(v[39] == 616); + assert_or_panic(v[40] == 617); + assert_or_panic(v[41] == 618); + assert_or_panic(v[42] == 619); + assert_or_panic(v[43] == 620); + assert_or_panic(v[44] == 621); + assert_or_panic(v[45] == 622); + assert_or_panic(v[46] == 623); + assert_or_panic(v[47] == 624); + assert_or_panic(i == 48); +} +void c_test_vector_48_f32(void) { + Vector_48_f32 v = zig_ret_vector_48_f32(); + assert_or_panic(v[0] == 433); + assert_or_panic(v[1] == 434); + assert_or_panic(v[2] == 435); + assert_or_panic(v[3] == 436); + assert_or_panic(v[4] == 437); + assert_or_panic(v[5] == 438); + assert_or_panic(v[6] == 439); + assert_or_panic(v[7] == 440); + assert_or_panic(v[8] == 441); + assert_or_panic(v[9] == 442); + assert_or_panic(v[10] == 443); + assert_or_panic(v[11] == 444); + assert_or_panic(v[12] == 445); + assert_or_panic(v[13] == 446); + assert_or_panic(v[14] == 447); + assert_or_panic(v[15] == 448); + assert_or_panic(v[16] == 449); + assert_or_panic(v[17] == 450); + assert_or_panic(v[18] == 451); + assert_or_panic(v[19] == 452); + assert_or_panic(v[20] == 453); + assert_or_panic(v[21] == 454); + assert_or_panic(v[22] == 455); + assert_or_panic(v[23] == 456); + assert_or_panic(v[24] == 457); + assert_or_panic(v[25] == 458); + assert_or_panic(v[26] == 459); + assert_or_panic(v[27] == 460); + assert_or_panic(v[28] == 461); + assert_or_panic(v[29] == 462); + assert_or_panic(v[30] == 463); + assert_or_panic(v[31] == 464); + assert_or_panic(v[32] == 465); + assert_or_panic(v[33] == 466); + assert_or_panic(v[34] == 467); + assert_or_panic(v[35] == 468); + assert_or_panic(v[36] == 469); + assert_or_panic(v[37] == 470); + assert_or_panic(v[38] == 471); + assert_or_panic(v[39] == 472); + assert_or_panic(v[40] == 473); + assert_or_panic(v[41] == 474); + assert_or_panic(v[42] == 475); + assert_or_panic(v[43] == 476); + assert_or_panic(v[44] == 477); + assert_or_panic(v[45] == 478); + assert_or_panic(v[46] == 479); + assert_or_panic(v[47] == 480); + zig_vector_48_f32((Vector_48_f32){ + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + }, 48); +} + +typedef float Vector_64_f32 __attribute__((vector_size(64 * sizeof(float)))); + +Vector_64_f32 zig_ret_vector_64_f32(void); +void zig_vector_64_f32(Vector_64_f32, size_t); + +Vector_64_f32 c_ret_vector_64_f32(void) { + return (Vector_64_f32){ + 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, + 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, + }; +} +void c_vector_64_f32(Vector_64_f32 v, size_t i) { + assert_or_panic(v[0] == 817); + assert_or_panic(v[1] == 818); + assert_or_panic(v[2] == 819); + assert_or_panic(v[3] == 820); + assert_or_panic(v[4] == 821); + assert_or_panic(v[5] == 822); + assert_or_panic(v[6] == 823); + assert_or_panic(v[7] == 824); + assert_or_panic(v[8] == 825); + assert_or_panic(v[9] == 826); + assert_or_panic(v[10] == 827); + assert_or_panic(v[11] == 828); + assert_or_panic(v[12] == 829); + assert_or_panic(v[13] == 830); + assert_or_panic(v[14] == 831); + assert_or_panic(v[15] == 832); + assert_or_panic(v[16] == 833); + assert_or_panic(v[17] == 834); + assert_or_panic(v[18] == 835); + assert_or_panic(v[19] == 836); + assert_or_panic(v[20] == 837); + assert_or_panic(v[21] == 838); + assert_or_panic(v[22] == 839); + assert_or_panic(v[23] == 840); + assert_or_panic(v[24] == 841); + assert_or_panic(v[25] == 842); + assert_or_panic(v[26] == 843); + assert_or_panic(v[27] == 844); + assert_or_panic(v[28] == 845); + assert_or_panic(v[29] == 846); + assert_or_panic(v[30] == 847); + assert_or_panic(v[31] == 848); + assert_or_panic(v[32] == 849); + assert_or_panic(v[33] == 850); + assert_or_panic(v[34] == 851); + assert_or_panic(v[35] == 852); + assert_or_panic(v[36] == 853); + assert_or_panic(v[37] == 854); + assert_or_panic(v[38] == 855); + assert_or_panic(v[39] == 856); + assert_or_panic(v[40] == 857); + assert_or_panic(v[41] == 858); + assert_or_panic(v[42] == 859); + assert_or_panic(v[43] == 860); + assert_or_panic(v[44] == 861); + assert_or_panic(v[45] == 862); + assert_or_panic(v[46] == 863); + assert_or_panic(v[47] == 864); + assert_or_panic(v[48] == 865); + assert_or_panic(v[49] == 866); + assert_or_panic(v[50] == 867); + assert_or_panic(v[51] == 868); + assert_or_panic(v[52] == 869); + assert_or_panic(v[53] == 870); + assert_or_panic(v[54] == 871); + assert_or_panic(v[55] == 872); + assert_or_panic(v[56] == 873); + assert_or_panic(v[57] == 874); + assert_or_panic(v[58] == 875); + assert_or_panic(v[59] == 876); + assert_or_panic(v[60] == 877); + assert_or_panic(v[61] == 878); + assert_or_panic(v[62] == 879); + assert_or_panic(v[63] == 880); + assert_or_panic(i == 64); +} +void c_test_vector_64_f32(void) { + Vector_64_f32 v = zig_ret_vector_64_f32(); + assert_or_panic(v[0] == 625); + assert_or_panic(v[1] == 626); + assert_or_panic(v[2] == 627); + assert_or_panic(v[3] == 628); + assert_or_panic(v[4] == 629); + assert_or_panic(v[5] == 630); + assert_or_panic(v[6] == 631); + assert_or_panic(v[7] == 632); + assert_or_panic(v[8] == 633); + assert_or_panic(v[9] == 634); + assert_or_panic(v[10] == 635); + assert_or_panic(v[11] == 636); + assert_or_panic(v[12] == 637); + assert_or_panic(v[13] == 638); + assert_or_panic(v[14] == 639); + assert_or_panic(v[15] == 640); + assert_or_panic(v[16] == 641); + assert_or_panic(v[17] == 642); + assert_or_panic(v[18] == 643); + assert_or_panic(v[19] == 644); + assert_or_panic(v[20] == 645); + assert_or_panic(v[21] == 646); + assert_or_panic(v[22] == 647); + assert_or_panic(v[23] == 648); + assert_or_panic(v[24] == 649); + assert_or_panic(v[25] == 650); + assert_or_panic(v[26] == 651); + assert_or_panic(v[27] == 652); + assert_or_panic(v[28] == 653); + assert_or_panic(v[29] == 654); + assert_or_panic(v[30] == 655); + assert_or_panic(v[31] == 656); + assert_or_panic(v[32] == 657); + assert_or_panic(v[33] == 658); + assert_or_panic(v[34] == 659); + assert_or_panic(v[35] == 660); + assert_or_panic(v[36] == 661); + assert_or_panic(v[37] == 662); + assert_or_panic(v[38] == 663); + assert_or_panic(v[39] == 664); + assert_or_panic(v[40] == 665); + assert_or_panic(v[41] == 666); + assert_or_panic(v[42] == 667); + assert_or_panic(v[43] == 668); + assert_or_panic(v[44] == 669); + assert_or_panic(v[45] == 670); + assert_or_panic(v[46] == 671); + assert_or_panic(v[47] == 672); + assert_or_panic(v[48] == 673); + assert_or_panic(v[49] == 674); + assert_or_panic(v[50] == 675); + assert_or_panic(v[51] == 676); + assert_or_panic(v[52] == 677); + assert_or_panic(v[53] == 678); + assert_or_panic(v[54] == 679); + assert_or_panic(v[55] == 680); + assert_or_panic(v[56] == 681); + assert_or_panic(v[57] == 682); + assert_or_panic(v[58] == 683); + assert_or_panic(v[59] == 684); + assert_or_panic(v[60] == 685); + assert_or_panic(v[61] == 686); + assert_or_panic(v[62] == 687); + assert_or_panic(v[63] == 688); + zig_vector_64_f32((Vector_64_f32){ + 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, + 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, + }, 64); +} + +typedef float Vector_96_f32 __attribute__((vector_size(96 * sizeof(float)))); + +Vector_96_f32 zig_ret_vector_96_f32(void); +void zig_vector_96_f32(Vector_96_f32, size_t); + +Vector_96_f32 c_ret_vector_96_f32(void) { + return (Vector_96_f32){ + 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, + 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, + 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, + 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, + 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, + 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, + }; +} +void c_vector_96_f32(Vector_96_f32 v, size_t i) { + assert_or_panic(v[0] == 1178); + assert_or_panic(v[1] == 1179); + assert_or_panic(v[2] == 1180); + assert_or_panic(v[3] == 1181); + assert_or_panic(v[4] == 1182); + assert_or_panic(v[5] == 1183); + assert_or_panic(v[6] == 1184); + assert_or_panic(v[7] == 1185); + assert_or_panic(v[8] == 1186); + assert_or_panic(v[9] == 1187); + assert_or_panic(v[10] == 1188); + assert_or_panic(v[11] == 1189); + assert_or_panic(v[12] == 1190); + assert_or_panic(v[13] == 1191); + assert_or_panic(v[14] == 1192); + assert_or_panic(v[15] == 1193); + assert_or_panic(v[16] == 1194); + assert_or_panic(v[17] == 1195); + assert_or_panic(v[18] == 1196); + assert_or_panic(v[19] == 1197); + assert_or_panic(v[20] == 1198); + assert_or_panic(v[21] == 1199); + assert_or_panic(v[22] == 1200); + assert_or_panic(v[23] == 1201); + assert_or_panic(v[24] == 1202); + assert_or_panic(v[25] == 1203); + assert_or_panic(v[26] == 1204); + assert_or_panic(v[27] == 1205); + assert_or_panic(v[28] == 1206); + assert_or_panic(v[29] == 1207); + assert_or_panic(v[30] == 1208); + assert_or_panic(v[31] == 1209); + assert_or_panic(v[32] == 1210); + assert_or_panic(v[33] == 1211); + assert_or_panic(v[34] == 1212); + assert_or_panic(v[35] == 1213); + assert_or_panic(v[36] == 1214); + assert_or_panic(v[37] == 1215); + assert_or_panic(v[38] == 1216); + assert_or_panic(v[39] == 1217); + assert_or_panic(v[40] == 1218); + assert_or_panic(v[41] == 1219); + assert_or_panic(v[42] == 1220); + assert_or_panic(v[43] == 1221); + assert_or_panic(v[44] == 1222); + assert_or_panic(v[45] == 1223); + assert_or_panic(v[46] == 1224); + assert_or_panic(v[47] == 1225); + assert_or_panic(v[48] == 1226); + assert_or_panic(v[49] == 1227); + assert_or_panic(v[50] == 1228); + assert_or_panic(v[51] == 1229); + assert_or_panic(v[52] == 1230); + assert_or_panic(v[53] == 1231); + assert_or_panic(v[54] == 1232); + assert_or_panic(v[55] == 1233); + assert_or_panic(v[56] == 1234); + assert_or_panic(v[57] == 1235); + assert_or_panic(v[58] == 1236); + assert_or_panic(v[59] == 1237); + assert_or_panic(v[60] == 1238); + assert_or_panic(v[61] == 1239); + assert_or_panic(v[62] == 1240); + assert_or_panic(v[63] == 1241); + assert_or_panic(v[64] == 1242); + assert_or_panic(v[65] == 1243); + assert_or_panic(v[66] == 1244); + assert_or_panic(v[67] == 1245); + assert_or_panic(v[68] == 1246); + assert_or_panic(v[69] == 1247); + assert_or_panic(v[70] == 1248); + assert_or_panic(v[71] == 1249); + assert_or_panic(v[72] == 1250); + assert_or_panic(v[73] == 1251); + assert_or_panic(v[74] == 1252); + assert_or_panic(v[75] == 1253); + assert_or_panic(v[76] == 1254); + assert_or_panic(v[77] == 1255); + assert_or_panic(v[80] == 1258); + assert_or_panic(v[81] == 1259); + assert_or_panic(v[82] == 1260); + assert_or_panic(v[83] == 1261); + assert_or_panic(v[84] == 1262); + assert_or_panic(v[85] == 1263); + assert_or_panic(v[86] == 1264); + assert_or_panic(v[87] == 1265); + assert_or_panic(v[88] == 1266); + assert_or_panic(v[89] == 1267); + assert_or_panic(v[90] == 1268); + assert_or_panic(v[91] == 1269); + assert_or_panic(v[92] == 1270); + assert_or_panic(v[93] == 1271); + assert_or_panic(v[94] == 1272); + assert_or_panic(v[95] == 1273); + assert_or_panic(i == 96); +} +void c_test_vector_96_f32(void) { + Vector_96_f32 v = zig_ret_vector_96_f32(); + assert_or_panic(v[0] == 890); + assert_or_panic(v[1] == 891); + assert_or_panic(v[2] == 892); + assert_or_panic(v[3] == 893); + assert_or_panic(v[4] == 894); + assert_or_panic(v[5] == 895); + assert_or_panic(v[6] == 896); + assert_or_panic(v[7] == 897); + assert_or_panic(v[8] == 898); + assert_or_panic(v[9] == 899); + assert_or_panic(v[10] == 900); + assert_or_panic(v[11] == 901); + assert_or_panic(v[12] == 902); + assert_or_panic(v[13] == 903); + assert_or_panic(v[14] == 904); + assert_or_panic(v[15] == 905); + assert_or_panic(v[16] == 906); + assert_or_panic(v[17] == 907); + assert_or_panic(v[18] == 908); + assert_or_panic(v[19] == 909); + assert_or_panic(v[20] == 910); + assert_or_panic(v[21] == 911); + assert_or_panic(v[22] == 912); + assert_or_panic(v[23] == 913); + assert_or_panic(v[24] == 914); + assert_or_panic(v[25] == 915); + assert_or_panic(v[26] == 916); + assert_or_panic(v[27] == 917); + assert_or_panic(v[28] == 918); + assert_or_panic(v[29] == 919); + assert_or_panic(v[30] == 920); + assert_or_panic(v[31] == 921); + assert_or_panic(v[32] == 922); + assert_or_panic(v[33] == 923); + assert_or_panic(v[34] == 924); + assert_or_panic(v[35] == 925); + assert_or_panic(v[36] == 926); + assert_or_panic(v[37] == 927); + assert_or_panic(v[38] == 928); + assert_or_panic(v[39] == 929); + assert_or_panic(v[40] == 930); + assert_or_panic(v[41] == 931); + assert_or_panic(v[42] == 932); + assert_or_panic(v[43] == 933); + assert_or_panic(v[44] == 934); + assert_or_panic(v[45] == 935); + assert_or_panic(v[46] == 936); + assert_or_panic(v[47] == 937); + assert_or_panic(v[48] == 938); + assert_or_panic(v[49] == 939); + assert_or_panic(v[50] == 940); + assert_or_panic(v[51] == 941); + assert_or_panic(v[52] == 942); + assert_or_panic(v[53] == 943); + assert_or_panic(v[54] == 944); + assert_or_panic(v[55] == 945); + assert_or_panic(v[56] == 946); + assert_or_panic(v[57] == 947); + assert_or_panic(v[58] == 948); + assert_or_panic(v[59] == 949); + assert_or_panic(v[60] == 950); + assert_or_panic(v[61] == 951); + assert_or_panic(v[62] == 952); + assert_or_panic(v[63] == 953); + assert_or_panic(v[64] == 954); + assert_or_panic(v[65] == 955); + assert_or_panic(v[66] == 956); + assert_or_panic(v[67] == 957); + assert_or_panic(v[68] == 958); + assert_or_panic(v[69] == 959); + assert_or_panic(v[70] == 960); + assert_or_panic(v[71] == 961); + assert_or_panic(v[72] == 962); + assert_or_panic(v[73] == 963); + assert_or_panic(v[74] == 964); + assert_or_panic(v[75] == 965); + assert_or_panic(v[76] == 966); + assert_or_panic(v[77] == 967); + assert_or_panic(v[78] == 968); + assert_or_panic(v[79] == 969); + assert_or_panic(v[80] == 970); + assert_or_panic(v[81] == 971); + assert_or_panic(v[82] == 972); + assert_or_panic(v[83] == 973); + assert_or_panic(v[84] == 974); + assert_or_panic(v[85] == 975); + assert_or_panic(v[86] == 976); + assert_or_panic(v[87] == 977); + assert_or_panic(v[88] == 978); + assert_or_panic(v[89] == 979); + assert_or_panic(v[90] == 980); + assert_or_panic(v[91] == 981); + assert_or_panic(v[92] == 982); + assert_or_panic(v[93] == 983); + assert_or_panic(v[94] == 984); + assert_or_panic(v[95] == 985); + zig_vector_96_f32((Vector_96_f32){ + 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, + 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, + 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, + 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, + 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, + 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, + }, 96); +} + +typedef float Vector_128_f32 __attribute__((vector_size(128 * sizeof(float)))); + +Vector_128_f32 zig_ret_vector_128_f32(void); +void zig_vector_128_f32(Vector_128_f32, size_t); + +Vector_128_f32 c_ret_vector_128_f32(void) { + return (Vector_128_f32){ + 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545, + 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, + 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, + 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, + 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, + 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, + }; +} +void c_vector_128_f32(Vector_128_f32 v, size_t i) { + assert_or_panic(v[0] == 1658); + assert_or_panic(v[1] == 1659); + assert_or_panic(v[2] == 1660); + assert_or_panic(v[3] == 1661); + assert_or_panic(v[4] == 1662); + assert_or_panic(v[5] == 1663); + assert_or_panic(v[6] == 1664); + assert_or_panic(v[7] == 1665); + assert_or_panic(v[8] == 1666); + assert_or_panic(v[9] == 1667); + assert_or_panic(v[10] == 1668); + assert_or_panic(v[11] == 1669); + assert_or_panic(v[12] == 1670); + assert_or_panic(v[13] == 1671); + assert_or_panic(v[14] == 1672); + assert_or_panic(v[15] == 1673); + assert_or_panic(v[16] == 1674); + assert_or_panic(v[17] == 1675); + assert_or_panic(v[18] == 1676); + assert_or_panic(v[19] == 1677); + assert_or_panic(v[20] == 1678); + assert_or_panic(v[21] == 1679); + assert_or_panic(v[22] == 1680); + assert_or_panic(v[23] == 1681); + assert_or_panic(v[24] == 1682); + assert_or_panic(v[25] == 1683); + assert_or_panic(v[26] == 1684); + assert_or_panic(v[27] == 1685); + assert_or_panic(v[28] == 1686); + assert_or_panic(v[29] == 1687); + assert_or_panic(v[30] == 1688); + assert_or_panic(v[31] == 1689); + assert_or_panic(v[32] == 1690); + assert_or_panic(v[33] == 1691); + assert_or_panic(v[34] == 1692); + assert_or_panic(v[35] == 1693); + assert_or_panic(v[36] == 1694); + assert_or_panic(v[37] == 1695); + assert_or_panic(v[38] == 1696); + assert_or_panic(v[39] == 1697); + assert_or_panic(v[40] == 1698); + assert_or_panic(v[41] == 1699); + assert_or_panic(v[42] == 1700); + assert_or_panic(v[43] == 1701); + assert_or_panic(v[44] == 1702); + assert_or_panic(v[45] == 1703); + assert_or_panic(v[46] == 1704); + assert_or_panic(v[47] == 1705); + assert_or_panic(v[48] == 1706); + assert_or_panic(v[49] == 1707); + assert_or_panic(v[50] == 1708); + assert_or_panic(v[51] == 1709); + assert_or_panic(v[52] == 1710); + assert_or_panic(v[53] == 1711); + assert_or_panic(v[54] == 1712); + assert_or_panic(v[55] == 1713); + assert_or_panic(v[56] == 1714); + assert_or_panic(v[57] == 1715); + assert_or_panic(v[58] == 1716); + assert_or_panic(v[59] == 1717); + assert_or_panic(v[60] == 1718); + assert_or_panic(v[61] == 1719); + assert_or_panic(v[62] == 1720); + assert_or_panic(v[63] == 1721); + assert_or_panic(v[64] == 1722); + assert_or_panic(v[65] == 1723); + assert_or_panic(v[66] == 1724); + assert_or_panic(v[67] == 1725); + assert_or_panic(v[68] == 1726); + assert_or_panic(v[69] == 1727); + assert_or_panic(v[70] == 1728); + assert_or_panic(v[71] == 1729); + assert_or_panic(v[72] == 1730); + assert_or_panic(v[73] == 1731); + assert_or_panic(v[74] == 1732); + assert_or_panic(v[75] == 1733); + assert_or_panic(v[76] == 1734); + assert_or_panic(v[77] == 1735); + assert_or_panic(v[78] == 1736); + assert_or_panic(v[79] == 1737); + assert_or_panic(v[80] == 1738); + assert_or_panic(v[81] == 1739); + assert_or_panic(v[82] == 1740); + assert_or_panic(v[83] == 1741); + assert_or_panic(v[84] == 1742); + assert_or_panic(v[85] == 1743); + assert_or_panic(v[86] == 1744); + assert_or_panic(v[87] == 1745); + assert_or_panic(v[88] == 1746); + assert_or_panic(v[89] == 1747); + assert_or_panic(v[90] == 1748); + assert_or_panic(v[91] == 1749); + assert_or_panic(v[92] == 1750); + assert_or_panic(v[93] == 1751); + assert_or_panic(v[94] == 1752); + assert_or_panic(v[95] == 1753); + assert_or_panic(v[96] == 1754); + assert_or_panic(v[97] == 1755); + assert_or_panic(v[98] == 1756); + assert_or_panic(v[99] == 1757); + assert_or_panic(v[100] == 1758); + assert_or_panic(v[101] == 1759); + assert_or_panic(v[102] == 1760); + assert_or_panic(v[103] == 1761); + assert_or_panic(v[104] == 1762); + assert_or_panic(v[105] == 1763); + assert_or_panic(v[106] == 1764); + assert_or_panic(v[107] == 1765); + assert_or_panic(v[108] == 1766); + assert_or_panic(v[109] == 1767); + assert_or_panic(v[110] == 1768); + assert_or_panic(v[111] == 1769); + assert_or_panic(v[112] == 1770); + assert_or_panic(v[113] == 1771); + assert_or_panic(v[114] == 1772); + assert_or_panic(v[115] == 1773); + assert_or_panic(v[116] == 1774); + assert_or_panic(v[117] == 1775); + assert_or_panic(v[118] == 1776); + assert_or_panic(v[119] == 1777); + assert_or_panic(v[120] == 1778); + assert_or_panic(v[121] == 1779); + assert_or_panic(v[122] == 1780); + assert_or_panic(v[123] == 1781); + assert_or_panic(v[124] == 1782); + assert_or_panic(v[125] == 1783); + assert_or_panic(v[126] == 1784); + assert_or_panic(v[127] == 1785); + assert_or_panic(i == 128); +} +void c_test_vector_128_f32(void) { + Vector_128_f32 v = zig_ret_vector_128_f32(); + assert_or_panic(v[0] == 1274); + assert_or_panic(v[1] == 1275); + assert_or_panic(v[2] == 1276); + assert_or_panic(v[3] == 1277); + assert_or_panic(v[4] == 1278); + assert_or_panic(v[5] == 1279); + assert_or_panic(v[6] == 1280); + assert_or_panic(v[7] == 1281); + assert_or_panic(v[8] == 1282); + assert_or_panic(v[9] == 1283); + assert_or_panic(v[10] == 1284); + assert_or_panic(v[11] == 1285); + assert_or_panic(v[12] == 1286); + assert_or_panic(v[13] == 1287); + assert_or_panic(v[14] == 1288); + assert_or_panic(v[15] == 1289); + assert_or_panic(v[16] == 1290); + assert_or_panic(v[17] == 1291); + assert_or_panic(v[18] == 1292); + assert_or_panic(v[19] == 1293); + assert_or_panic(v[20] == 1294); + assert_or_panic(v[21] == 1295); + assert_or_panic(v[22] == 1296); + assert_or_panic(v[23] == 1297); + assert_or_panic(v[24] == 1298); + assert_or_panic(v[25] == 1299); + assert_or_panic(v[26] == 1300); + assert_or_panic(v[27] == 1301); + assert_or_panic(v[28] == 1302); + assert_or_panic(v[29] == 1303); + assert_or_panic(v[30] == 1304); + assert_or_panic(v[31] == 1305); + assert_or_panic(v[32] == 1306); + assert_or_panic(v[33] == 1307); + assert_or_panic(v[34] == 1308); + assert_or_panic(v[35] == 1309); + assert_or_panic(v[36] == 1310); + assert_or_panic(v[37] == 1311); + assert_or_panic(v[38] == 1312); + assert_or_panic(v[39] == 1313); + assert_or_panic(v[40] == 1314); + assert_or_panic(v[41] == 1315); + assert_or_panic(v[42] == 1316); + assert_or_panic(v[43] == 1317); + assert_or_panic(v[44] == 1318); + assert_or_panic(v[45] == 1319); + assert_or_panic(v[46] == 1320); + assert_or_panic(v[47] == 1321); + assert_or_panic(v[48] == 1322); + assert_or_panic(v[49] == 1323); + assert_or_panic(v[50] == 1324); + assert_or_panic(v[51] == 1325); + assert_or_panic(v[52] == 1326); + assert_or_panic(v[53] == 1327); + assert_or_panic(v[54] == 1328); + assert_or_panic(v[55] == 1329); + assert_or_panic(v[56] == 1330); + assert_or_panic(v[57] == 1331); + assert_or_panic(v[58] == 1332); + assert_or_panic(v[59] == 1333); + assert_or_panic(v[60] == 1334); + assert_or_panic(v[61] == 1335); + assert_or_panic(v[62] == 1336); + assert_or_panic(v[63] == 1337); + assert_or_panic(v[64] == 1338); + assert_or_panic(v[65] == 1339); + assert_or_panic(v[66] == 1340); + assert_or_panic(v[67] == 1341); + assert_or_panic(v[68] == 1342); + assert_or_panic(v[69] == 1343); + assert_or_panic(v[70] == 1344); + assert_or_panic(v[71] == 1345); + assert_or_panic(v[72] == 1346); + assert_or_panic(v[73] == 1347); + assert_or_panic(v[74] == 1348); + assert_or_panic(v[75] == 1349); + assert_or_panic(v[76] == 1350); + assert_or_panic(v[77] == 1351); + assert_or_panic(v[78] == 1352); + assert_or_panic(v[79] == 1353); + assert_or_panic(v[80] == 1354); + assert_or_panic(v[81] == 1355); + assert_or_panic(v[82] == 1356); + assert_or_panic(v[83] == 1357); + assert_or_panic(v[84] == 1358); + assert_or_panic(v[85] == 1359); + assert_or_panic(v[86] == 1360); + assert_or_panic(v[87] == 1361); + assert_or_panic(v[88] == 1362); + assert_or_panic(v[89] == 1363); + assert_or_panic(v[90] == 1364); + assert_or_panic(v[91] == 1365); + assert_or_panic(v[92] == 1366); + assert_or_panic(v[93] == 1367); + assert_or_panic(v[94] == 1368); + assert_or_panic(v[95] == 1369); + assert_or_panic(v[96] == 1370); + assert_or_panic(v[97] == 1371); + assert_or_panic(v[98] == 1372); + assert_or_panic(v[99] == 1373); + assert_or_panic(v[100] == 1374); + assert_or_panic(v[101] == 1375); + assert_or_panic(v[102] == 1376); + assert_or_panic(v[103] == 1377); + assert_or_panic(v[104] == 1378); + assert_or_panic(v[105] == 1379); + assert_or_panic(v[106] == 1380); + assert_or_panic(v[107] == 1381); + assert_or_panic(v[108] == 1382); + assert_or_panic(v[109] == 1383); + assert_or_panic(v[110] == 1384); + assert_or_panic(v[111] == 1385); + assert_or_panic(v[112] == 1386); + assert_or_panic(v[113] == 1387); + assert_or_panic(v[114] == 1388); + assert_or_panic(v[115] == 1389); + assert_or_panic(v[116] == 1390); + assert_or_panic(v[117] == 1391); + assert_or_panic(v[118] == 1392); + assert_or_panic(v[119] == 1393); + assert_or_panic(v[120] == 1394); + assert_or_panic(v[121] == 1395); + assert_or_panic(v[122] == 1396); + assert_or_panic(v[123] == 1397); + assert_or_panic(v[124] == 1398); + assert_or_panic(v[125] == 1399); + assert_or_panic(v[126] == 1400); + assert_or_panic(v[127] == 1401); + zig_vector_128_f32((Vector_128_f32){ + 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, + 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, + 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, + 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, + 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, + 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, + 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, + 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, + }, 128); +} + +typedef double Vector_1_f64 __attribute__((vector_size(1 * sizeof(double)))); + +Vector_1_f64 zig_ret_vector_1_f64(void); +void zig_vector_1_f64(Vector_1_f64, size_t); + +Vector_1_f64 c_ret_vector_1_f64(void) { + return (Vector_1_f64){ 3 }; +} +void c_vector_1_f64(Vector_1_f64 v, size_t i) { + assert_or_panic(v[0] == 4); + assert_or_panic(i == 1); +} +void c_test_vector_1_f64(void) { + Vector_1_f64 v = zig_ret_vector_1_f64(); + assert_or_panic(v[0] == 1); + zig_vector_1_f64((Vector_1_f64){ 2 }, 1); +} + +typedef double Vector_2_f64 __attribute__((vector_size(2 * sizeof(double)))); + +Vector_2_f64 zig_ret_vector_2_f64(void); +void zig_vector_2_f64(Vector_2_f64, size_t); + +Vector_2_f64 c_ret_vector_2_f64(void) { + return (Vector_2_f64){ 9, 10 }; +} +void c_vector_2_f64(Vector_2_f64 v, size_t i) { + assert_or_panic(v[0] == 11); + assert_or_panic(v[1] == 12); + assert_or_panic(i == 2); +} +void c_test_vector_2_f64(void) { + Vector_2_f64 v = zig_ret_vector_2_f64(); + assert_or_panic(v[0] == 5); + assert_or_panic(v[1] == 6); + zig_vector_2_f64((Vector_2_f64){ 7, 8 }, 2); +} + +typedef double Vector_3_f64 __attribute__((vector_size(3 * sizeof(double)))); + +Vector_3_f64 zig_ret_vector_3_f64(void); +void zig_vector_3_f64(Vector_3_f64, size_t); + +Vector_3_f64 c_ret_vector_3_f64(void) { + return (Vector_3_f64){ 19, 20, 21 }; +} +void c_vector_3_f64(Vector_3_f64 v, size_t i) { + assert_or_panic(v[0] == 22); + assert_or_panic(v[1] == 23); + assert_or_panic(v[2] == 24); + assert_or_panic(i == 3); +} +void c_test_vector_3_f64(void) { + Vector_3_f64 v = zig_ret_vector_3_f64(); + assert_or_panic(v[0] == 13); + assert_or_panic(v[1] == 14); + assert_or_panic(v[2] == 15); + zig_vector_3_f64((Vector_3_f64){ 16, 17, 18 }, 3); +} + +typedef double Vector_4_f64 __attribute__((vector_size(4 * sizeof(double)))); + +Vector_4_f64 zig_ret_vector_4_f64(void); +void zig_vector_4_f64(Vector_4_f64, size_t); + +Vector_4_f64 c_ret_vector_4_f64(void) { + return (Vector_4_f64){ 33, 34, 35, 36 }; +} +void c_vector_4_f64(Vector_4_f64 v, size_t i) { + assert_or_panic(v[0] == 37); + assert_or_panic(v[1] == 38); + assert_or_panic(v[2] == 39); + assert_or_panic(v[3] == 40); + assert_or_panic(i == 4); +} +void c_test_vector_4_f64(void) { + Vector_4_f64 v = zig_ret_vector_4_f64(); + assert_or_panic(v[0] == 25); + assert_or_panic(v[1] == 26); + assert_or_panic(v[2] == 27); + assert_or_panic(v[3] == 28); + zig_vector_4_f64((Vector_4_f64){ 29, 30, 31, 32 }, 4); +} + +typedef double Vector_6_f64 __attribute__((vector_size(6 * sizeof(double)))); + +Vector_6_f64 zig_ret_vector_6_f64(void); +void zig_vector_6_f64(Vector_6_f64, size_t); + +Vector_6_f64 c_ret_vector_6_f64(void) { + return (Vector_6_f64){ 53, 54, 55, 56, 57, 58 }; +} +void c_vector_6_f64(Vector_6_f64 v, size_t i) { + assert_or_panic(v[0] == 59); + assert_or_panic(v[1] == 60); + assert_or_panic(v[2] == 61); + assert_or_panic(v[3] == 62); + assert_or_panic(v[4] == 63); + assert_or_panic(v[5] == 64); + assert_or_panic(i == 6); +} +void c_test_vector_6_f64(void) { + Vector_6_f64 v = zig_ret_vector_6_f64(); + assert_or_panic(v[0] == 41); + assert_or_panic(v[1] == 42); + assert_or_panic(v[2] == 43); + assert_or_panic(v[3] == 44); + assert_or_panic(v[4] == 45); + assert_or_panic(v[5] == 46); + zig_vector_6_f64((Vector_6_f64){ 47, 48, 49, 50, 51, 52 }, 6); +} + +typedef double Vector_8_f64 __attribute__((vector_size(8 * sizeof(double)))); + +Vector_8_f64 zig_ret_vector_8_f64(void); +void zig_vector_8_f64(Vector_8_f64, size_t); + +Vector_8_f64 c_ret_vector_8_f64(void) { + return (Vector_8_f64){ 81, 82, 83, 84, 85, 86, 87, 88 }; +} +void c_vector_8_f64(Vector_8_f64 v, size_t i) { + assert_or_panic(v[0] == 89); + assert_or_panic(v[1] == 90); + assert_or_panic(v[2] == 91); + assert_or_panic(v[3] == 92); + assert_or_panic(v[4] == 93); + assert_or_panic(v[5] == 94); + assert_or_panic(v[6] == 95); + assert_or_panic(v[7] == 96); + assert_or_panic(i == 8); +} +void c_test_vector_8_f64(void) { + Vector_8_f64 v = zig_ret_vector_8_f64(); + assert_or_panic(v[0] == 65); + assert_or_panic(v[1] == 66); + assert_or_panic(v[2] == 67); + assert_or_panic(v[3] == 68); + assert_or_panic(v[4] == 69); + assert_or_panic(v[5] == 70); + assert_or_panic(v[6] == 71); + assert_or_panic(v[7] == 72); + zig_vector_8_f64((Vector_8_f64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8); +} + +typedef double Vector_12_f64 __attribute__((vector_size(12 * sizeof(double)))); + +Vector_12_f64 zig_ret_vector_12_f64(void); +void zig_vector_12_f64(Vector_12_f64, size_t); + +Vector_12_f64 c_ret_vector_12_f64(void) { + return (Vector_12_f64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 }; +} +void c_vector_12_f64(Vector_12_f64 v, size_t i) { + assert_or_panic(v[0] == 133); + assert_or_panic(v[1] == 134); + assert_or_panic(v[2] == 135); + assert_or_panic(v[3] == 136); + assert_or_panic(v[4] == 137); + assert_or_panic(v[5] == 138); + assert_or_panic(v[6] == 139); + assert_or_panic(v[7] == 140); + assert_or_panic(v[8] == 141); + assert_or_panic(v[9] == 142); + assert_or_panic(v[10] == 143); + assert_or_panic(v[11] == 144); + assert_or_panic(i == 12); +} +void c_test_vector_12_f64(void) { + Vector_12_f64 v = zig_ret_vector_12_f64(); + assert_or_panic(v[0] == 97); + assert_or_panic(v[1] == 98); + assert_or_panic(v[2] == 99); + assert_or_panic(v[3] == 100); + assert_or_panic(v[4] == 101); + assert_or_panic(v[5] == 102); + assert_or_panic(v[6] == 103); + assert_or_panic(v[7] == 104); + assert_or_panic(v[8] == 105); + assert_or_panic(v[9] == 106); + assert_or_panic(v[10] == 107); + assert_or_panic(v[11] == 108); + zig_vector_12_f64((Vector_12_f64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12); +} + +typedef double Vector_16_f64 __attribute__((vector_size(16 * sizeof(double)))); + +Vector_16_f64 zig_ret_vector_16_f64(void); +void zig_vector_16_f64(Vector_16_f64, size_t); + +Vector_16_f64 c_ret_vector_16_f64(void) { + return (Vector_16_f64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 }; +} +void c_vector_16_f64(Vector_16_f64 v, size_t i) { + assert_or_panic(v[0] == 193); + assert_or_panic(v[1] == 194); + assert_or_panic(v[2] == 195); + assert_or_panic(v[3] == 196); + assert_or_panic(v[4] == 197); + assert_or_panic(v[5] == 198); + assert_or_panic(v[6] == 199); + assert_or_panic(v[7] == 200); + assert_or_panic(v[8] == 201); + assert_or_panic(v[9] == 202); + assert_or_panic(v[10] == 203); + assert_or_panic(v[11] == 204); + assert_or_panic(v[12] == 205); + assert_or_panic(v[13] == 206); + assert_or_panic(v[14] == 207); + assert_or_panic(v[15] == 208); + assert_or_panic(i == 16); +} +void c_test_vector_16_f64(void) { + Vector_16_f64 v = zig_ret_vector_16_f64(); + assert_or_panic(v[0] == 145); + assert_or_panic(v[1] == 146); + assert_or_panic(v[2] == 147); + assert_or_panic(v[3] == 148); + assert_or_panic(v[4] == 149); + assert_or_panic(v[5] == 150); + assert_or_panic(v[6] == 151); + assert_or_panic(v[7] == 152); + assert_or_panic(v[8] == 153); + assert_or_panic(v[9] == 154); + assert_or_panic(v[10] == 155); + assert_or_panic(v[11] == 156); + assert_or_panic(v[12] == 157); + assert_or_panic(v[13] == 158); + assert_or_panic(v[14] == 159); + assert_or_panic(v[15] == 160); + zig_vector_16_f64((Vector_16_f64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16); +} + +typedef double Vector_24_f64 __attribute__((vector_size(24 * sizeof(double)))); + +Vector_24_f64 zig_ret_vector_24_f64(void); +void zig_vector_24_f64(Vector_24_f64, size_t); + +Vector_24_f64 c_ret_vector_24_f64(void) { + return (Vector_24_f64){ + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, + }; +} +void c_vector_24_f64(Vector_24_f64 v, size_t i) { + assert_or_panic(v[0] == 281); + assert_or_panic(v[1] == 282); + assert_or_panic(v[2] == 283); + assert_or_panic(v[3] == 284); + assert_or_panic(v[4] == 285); + assert_or_panic(v[5] == 286); + assert_or_panic(v[6] == 287); + assert_or_panic(v[7] == 288); + assert_or_panic(v[8] == 289); + assert_or_panic(v[9] == 290); + assert_or_panic(v[10] == 291); + assert_or_panic(v[11] == 292); + assert_or_panic(v[12] == 293); + assert_or_panic(v[13] == 294); + assert_or_panic(v[14] == 295); + assert_or_panic(v[15] == 296); + assert_or_panic(v[16] == 297); + assert_or_panic(v[17] == 298); + assert_or_panic(v[18] == 299); + assert_or_panic(v[19] == 300); + assert_or_panic(v[20] == 301); + assert_or_panic(v[21] == 302); + assert_or_panic(v[22] == 303); + assert_or_panic(v[23] == 304); + assert_or_panic(i == 24); +} +void c_test_vector_24_f64(void) { + Vector_24_f64 v = zig_ret_vector_24_f64(); + assert_or_panic(v[0] == 209); + assert_or_panic(v[1] == 210); + assert_or_panic(v[2] == 211); + assert_or_panic(v[3] == 212); + assert_or_panic(v[4] == 213); + assert_or_panic(v[5] == 214); + assert_or_panic(v[6] == 215); + assert_or_panic(v[7] == 216); + assert_or_panic(v[8] == 217); + assert_or_panic(v[9] == 218); + assert_or_panic(v[10] == 219); + assert_or_panic(v[11] == 220); + assert_or_panic(v[12] == 221); + assert_or_panic(v[13] == 222); + assert_or_panic(v[14] == 223); + assert_or_panic(v[15] == 224); + assert_or_panic(v[16] == 225); + assert_or_panic(v[17] == 226); + assert_or_panic(v[18] == 227); + assert_or_panic(v[19] == 228); + assert_or_panic(v[20] == 229); + assert_or_panic(v[21] == 230); + assert_or_panic(v[22] == 231); + assert_or_panic(v[23] == 232); + zig_vector_24_f64((Vector_24_f64){ + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, + }, 24); +} + +typedef double Vector_32_f64 __attribute__((vector_size(32 * sizeof(double)))); + +Vector_32_f64 zig_ret_vector_32_f64(void); +void zig_vector_32_f64(Vector_32_f64, size_t); + +Vector_32_f64 c_ret_vector_32_f64(void) { + return (Vector_32_f64){ + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + }; +} +void c_vector_32_f64(Vector_32_f64 v, size_t i) { + assert_or_panic(v[0] == 401); + assert_or_panic(v[1] == 402); + assert_or_panic(v[2] == 403); + assert_or_panic(v[3] == 404); + assert_or_panic(v[4] == 405); + assert_or_panic(v[5] == 406); + assert_or_panic(v[6] == 407); + assert_or_panic(v[7] == 408); + assert_or_panic(v[8] == 409); + assert_or_panic(v[9] == 410); + assert_or_panic(v[10] == 411); + assert_or_panic(v[11] == 412); + assert_or_panic(v[12] == 413); + assert_or_panic(v[13] == 414); + assert_or_panic(v[14] == 415); + assert_or_panic(v[15] == 416); + assert_or_panic(v[16] == 417); + assert_or_panic(v[17] == 418); + assert_or_panic(v[18] == 419); + assert_or_panic(v[19] == 420); + assert_or_panic(v[20] == 421); + assert_or_panic(v[21] == 422); + assert_or_panic(v[22] == 423); + assert_or_panic(v[23] == 424); + assert_or_panic(v[24] == 425); + assert_or_panic(v[25] == 426); + assert_or_panic(v[26] == 427); + assert_or_panic(v[27] == 428); + assert_or_panic(v[28] == 429); + assert_or_panic(v[29] == 430); + assert_or_panic(v[30] == 431); + assert_or_panic(v[31] == 432); + assert_or_panic(i == 32); +} +void c_test_vector_32_f64(void) { + Vector_32_f64 v = zig_ret_vector_32_f64(); + assert_or_panic(v[0] == 305); + assert_or_panic(v[1] == 306); + assert_or_panic(v[2] == 307); + assert_or_panic(v[3] == 308); + assert_or_panic(v[4] == 309); + assert_or_panic(v[5] == 310); + assert_or_panic(v[6] == 311); + assert_or_panic(v[7] == 312); + assert_or_panic(v[8] == 313); + assert_or_panic(v[9] == 314); + assert_or_panic(v[10] == 315); + assert_or_panic(v[11] == 316); + assert_or_panic(v[12] == 317); + assert_or_panic(v[13] == 318); + assert_or_panic(v[14] == 319); + assert_or_panic(v[15] == 320); + assert_or_panic(v[16] == 321); + assert_or_panic(v[17] == 322); + assert_or_panic(v[18] == 323); + assert_or_panic(v[19] == 324); + assert_or_panic(v[20] == 325); + assert_or_panic(v[21] == 326); + assert_or_panic(v[22] == 327); + assert_or_panic(v[23] == 328); + assert_or_panic(v[24] == 329); + assert_or_panic(v[25] == 330); + assert_or_panic(v[26] == 331); + assert_or_panic(v[27] == 332); + assert_or_panic(v[28] == 333); + assert_or_panic(v[29] == 334); + assert_or_panic(v[30] == 335); + assert_or_panic(v[31] == 336); + zig_vector_32_f64((Vector_32_f64){ + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + }, 32); +} + +typedef double Vector_48_f64 __attribute__((vector_size(48 * sizeof(double)))); + +Vector_48_f64 zig_ret_vector_48_f64(void); +void zig_vector_48_f64(Vector_48_f64, size_t); + +Vector_48_f64 c_ret_vector_48_f64(void) { + return (Vector_48_f64){ + 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, + 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, + 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, + }; +} +void c_vector_48_f64(Vector_48_f64 v, size_t i) { + assert_or_panic(v[0] == 577); + assert_or_panic(v[1] == 578); + assert_or_panic(v[2] == 579); + assert_or_panic(v[3] == 580); + assert_or_panic(v[4] == 581); + assert_or_panic(v[5] == 582); + assert_or_panic(v[6] == 583); + assert_or_panic(v[7] == 584); + assert_or_panic(v[8] == 585); + assert_or_panic(v[9] == 586); + assert_or_panic(v[10] == 587); + assert_or_panic(v[11] == 588); + assert_or_panic(v[12] == 589); + assert_or_panic(v[13] == 590); + assert_or_panic(v[14] == 591); + assert_or_panic(v[15] == 592); + assert_or_panic(v[16] == 593); + assert_or_panic(v[17] == 594); + assert_or_panic(v[18] == 595); + assert_or_panic(v[19] == 596); + assert_or_panic(v[20] == 597); + assert_or_panic(v[21] == 598); + assert_or_panic(v[22] == 599); + assert_or_panic(v[23] == 600); + assert_or_panic(v[24] == 601); + assert_or_panic(v[25] == 602); + assert_or_panic(v[26] == 603); + assert_or_panic(v[27] == 604); + assert_or_panic(v[28] == 605); + assert_or_panic(v[29] == 606); + assert_or_panic(v[30] == 607); + assert_or_panic(v[31] == 608); + assert_or_panic(v[32] == 609); + assert_or_panic(v[33] == 610); + assert_or_panic(v[34] == 611); + assert_or_panic(v[35] == 612); + assert_or_panic(v[36] == 613); + assert_or_panic(v[37] == 614); + assert_or_panic(v[38] == 615); + assert_or_panic(v[39] == 616); + assert_or_panic(v[40] == 617); + assert_or_panic(v[41] == 618); + assert_or_panic(v[42] == 619); + assert_or_panic(v[43] == 620); + assert_or_panic(v[44] == 621); + assert_or_panic(v[45] == 622); + assert_or_panic(v[46] == 623); + assert_or_panic(v[47] == 624); + assert_or_panic(i == 48); +} +void c_test_vector_48_f64(void) { + Vector_48_f64 v = zig_ret_vector_48_f64(); + assert_or_panic(v[0] == 433); + assert_or_panic(v[1] == 434); + assert_or_panic(v[2] == 435); + assert_or_panic(v[3] == 436); + assert_or_panic(v[4] == 437); + assert_or_panic(v[5] == 438); + assert_or_panic(v[6] == 439); + assert_or_panic(v[7] == 440); + assert_or_panic(v[8] == 441); + assert_or_panic(v[9] == 442); + assert_or_panic(v[10] == 443); + assert_or_panic(v[11] == 444); + assert_or_panic(v[12] == 445); + assert_or_panic(v[13] == 446); + assert_or_panic(v[14] == 447); + assert_or_panic(v[15] == 448); + assert_or_panic(v[16] == 449); + assert_or_panic(v[17] == 450); + assert_or_panic(v[18] == 451); + assert_or_panic(v[19] == 452); + assert_or_panic(v[20] == 453); + assert_or_panic(v[21] == 454); + assert_or_panic(v[22] == 455); + assert_or_panic(v[23] == 456); + assert_or_panic(v[24] == 457); + assert_or_panic(v[25] == 458); + assert_or_panic(v[26] == 459); + assert_or_panic(v[27] == 460); + assert_or_panic(v[28] == 461); + assert_or_panic(v[29] == 462); + assert_or_panic(v[30] == 463); + assert_or_panic(v[31] == 464); + assert_or_panic(v[32] == 465); + assert_or_panic(v[33] == 466); + assert_or_panic(v[34] == 467); + assert_or_panic(v[35] == 468); + assert_or_panic(v[36] == 469); + assert_or_panic(v[37] == 470); + assert_or_panic(v[38] == 471); + assert_or_panic(v[39] == 472); + assert_or_panic(v[40] == 473); + assert_or_panic(v[41] == 474); + assert_or_panic(v[42] == 475); + assert_or_panic(v[43] == 476); + assert_or_panic(v[44] == 477); + assert_or_panic(v[45] == 478); + assert_or_panic(v[46] == 479); + assert_or_panic(v[47] == 480); + zig_vector_48_f64((Vector_48_f64){ + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + }, 48); +} + +typedef double Vector_64_f64 __attribute__((vector_size(64 * sizeof(double)))); + +Vector_64_f64 zig_ret_vector_64_f64(void); +void zig_vector_64_f64(Vector_64_f64, size_t); + +Vector_64_f64 c_ret_vector_64_f64(void) { + return (Vector_64_f64){ + 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, + 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, + 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, }; } +void c_vector_64_f64(Vector_64_f64 v, size_t i) { + assert_or_panic(v[0] == 817); + assert_or_panic(v[1] == 818); + assert_or_panic(v[2] == 819); + assert_or_panic(v[3] == 820); + assert_or_panic(v[4] == 821); + assert_or_panic(v[5] == 822); + assert_or_panic(v[6] == 823); + assert_or_panic(v[7] == 824); + assert_or_panic(v[8] == 825); + assert_or_panic(v[9] == 826); + assert_or_panic(v[10] == 827); + assert_or_panic(v[11] == 828); + assert_or_panic(v[12] == 829); + assert_or_panic(v[13] == 830); + assert_or_panic(v[14] == 831); + assert_or_panic(v[15] == 832); + assert_or_panic(v[16] == 833); + assert_or_panic(v[17] == 834); + assert_or_panic(v[18] == 835); + assert_or_panic(v[19] == 836); + assert_or_panic(v[20] == 837); + assert_or_panic(v[21] == 838); + assert_or_panic(v[22] == 839); + assert_or_panic(v[23] == 840); + assert_or_panic(v[24] == 841); + assert_or_panic(v[25] == 842); + assert_or_panic(v[26] == 843); + assert_or_panic(v[27] == 844); + assert_or_panic(v[28] == 845); + assert_or_panic(v[29] == 846); + assert_or_panic(v[30] == 847); + assert_or_panic(v[31] == 848); + assert_or_panic(v[32] == 849); + assert_or_panic(v[33] == 850); + assert_or_panic(v[34] == 851); + assert_or_panic(v[35] == 852); + assert_or_panic(v[36] == 853); + assert_or_panic(v[37] == 854); + assert_or_panic(v[38] == 855); + assert_or_panic(v[39] == 856); + assert_or_panic(v[40] == 857); + assert_or_panic(v[41] == 858); + assert_or_panic(v[42] == 859); + assert_or_panic(v[43] == 860); + assert_or_panic(v[44] == 861); + assert_or_panic(v[45] == 862); + assert_or_panic(v[46] == 863); + assert_or_panic(v[47] == 864); + assert_or_panic(v[48] == 865); + assert_or_panic(v[49] == 866); + assert_or_panic(v[50] == 867); + assert_or_panic(v[51] == 868); + assert_or_panic(v[52] == 869); + assert_or_panic(v[53] == 870); + assert_or_panic(v[54] == 871); + assert_or_panic(v[55] == 872); + assert_or_panic(v[56] == 873); + assert_or_panic(v[57] == 874); + assert_or_panic(v[58] == 875); + assert_or_panic(v[59] == 876); + assert_or_panic(v[60] == 877); + assert_or_panic(v[61] == 878); + assert_or_panic(v[62] == 879); + assert_or_panic(v[63] == 880); + assert_or_panic(i == 64); +} +void c_test_vector_64_f64(void) { + Vector_64_f64 v = zig_ret_vector_64_f64(); + assert_or_panic(v[0] == 625); + assert_or_panic(v[1] == 626); + assert_or_panic(v[2] == 627); + assert_or_panic(v[3] == 628); + assert_or_panic(v[4] == 629); + assert_or_panic(v[5] == 630); + assert_or_panic(v[6] == 631); + assert_or_panic(v[7] == 632); + assert_or_panic(v[8] == 633); + assert_or_panic(v[9] == 634); + assert_or_panic(v[10] == 635); + assert_or_panic(v[11] == 636); + assert_or_panic(v[12] == 637); + assert_or_panic(v[13] == 638); + assert_or_panic(v[14] == 639); + assert_or_panic(v[15] == 640); + assert_or_panic(v[16] == 641); + assert_or_panic(v[17] == 642); + assert_or_panic(v[18] == 643); + assert_or_panic(v[19] == 644); + assert_or_panic(v[20] == 645); + assert_or_panic(v[21] == 646); + assert_or_panic(v[22] == 647); + assert_or_panic(v[23] == 648); + assert_or_panic(v[24] == 649); + assert_or_panic(v[25] == 650); + assert_or_panic(v[26] == 651); + assert_or_panic(v[27] == 652); + assert_or_panic(v[28] == 653); + assert_or_panic(v[29] == 654); + assert_or_panic(v[30] == 655); + assert_or_panic(v[31] == 656); + assert_or_panic(v[32] == 657); + assert_or_panic(v[33] == 658); + assert_or_panic(v[34] == 659); + assert_or_panic(v[35] == 660); + assert_or_panic(v[36] == 661); + assert_or_panic(v[37] == 662); + assert_or_panic(v[38] == 663); + assert_or_panic(v[39] == 664); + assert_or_panic(v[40] == 665); + assert_or_panic(v[41] == 666); + assert_or_panic(v[42] == 667); + assert_or_panic(v[43] == 668); + assert_or_panic(v[44] == 669); + assert_or_panic(v[45] == 670); + assert_or_panic(v[46] == 671); + assert_or_panic(v[47] == 672); + assert_or_panic(v[48] == 673); + assert_or_panic(v[49] == 674); + assert_or_panic(v[50] == 675); + assert_or_panic(v[51] == 676); + assert_or_panic(v[52] == 677); + assert_or_panic(v[53] == 678); + assert_or_panic(v[54] == 679); + assert_or_panic(v[55] == 680); + assert_or_panic(v[56] == 681); + assert_or_panic(v[57] == 682); + assert_or_panic(v[58] == 683); + assert_or_panic(v[59] == 684); + assert_or_panic(v[60] == 685); + assert_or_panic(v[61] == 686); + assert_or_panic(v[62] == 687); + assert_or_panic(v[63] == 688); + zig_vector_64_f64((Vector_64_f64){ + 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, + 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, + 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, + }, 64); +} + +struct Struct_u8 { + uint8_t a; +}; + +struct Struct_u8 zig_ret_struct_u8(void); +void zig_struct_u8(struct Struct_u8, size_t); + +struct Struct_u8 c_ret_struct_u8(void) { + return (struct Struct_u8){ .a = 4 }; +} +void c_struct_u8(struct Struct_u8 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_u8(void) { + struct Struct_u8 s = zig_ret_struct_u8(); + assert_or_panic(s.a == 1); + zig_struct_u8((struct Struct_u8){ .a = 2 }, 3); +} + +struct Struct_u8_u8 { + uint8_t a, b; +}; + +struct Struct_u8_u8 zig_ret_struct_u8_u8(void); +void zig_struct_u8_u8(struct Struct_u8_u8, size_t); + +struct Struct_u8_u8 c_ret_struct_u8_u8(void) { + return (struct Struct_u8_u8){ .a = 6, .b = 7 }; +} +void c_struct_u8_u8(struct Struct_u8_u8 s, size_t i) { + assert_or_panic(s.a == 8); + assert_or_panic(s.b == 9); + assert_or_panic(i == 10); +} +void c_test_struct_u8_u8(void) { + struct Struct_u8_u8 s = zig_ret_struct_u8_u8(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_u8_u8((struct Struct_u8_u8){ .a = 3, .b = 4 }, 5); +} + +struct Struct_u8_u8_u8 { + uint8_t a, b, c; +}; + +struct Struct_u8_u8_u8 zig_ret_struct_u8_u8_u8(void); +void zig_struct_u8_u8_u8(struct Struct_u8_u8_u8, size_t); + +struct Struct_u8_u8_u8 c_ret_struct_u8_u8_u8(void) { + return (struct Struct_u8_u8_u8){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_u8_u8_u8(struct Struct_u8_u8_u8 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_u8_u8_u8(void) { + struct Struct_u8_u8_u8 s = zig_ret_struct_u8_u8_u8(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_u8_u8_u8((struct Struct_u8_u8_u8){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_u8_u8_u8_u8 { + uint8_t a, b, c, d; +}; + +struct Struct_u8_u8_u8_u8 zig_ret_struct_u8_u8_u8_u8(void); +void zig_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8, size_t); + +struct Struct_u8_u8_u8_u8 c_ret_struct_u8_u8_u8_u8(void) { + return (struct Struct_u8_u8_u8_u8){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_u8_u8_u8_u8(void) { + struct Struct_u8_u8_u8_u8 s = zig_ret_struct_u8_u8_u8_u8(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_u8_u8_u8_u8((struct Struct_u8_u8_u8_u8){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_u16 { + uint16_t a; +}; + +struct Struct_u16 zig_ret_struct_u16(void); +void zig_struct_u16(struct Struct_u16, size_t); + +struct Struct_u16 c_ret_struct_u16(void) { + return (struct Struct_u16){ .a = 4 }; +} +void c_struct_u16(struct Struct_u16 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_u16(void) { + struct Struct_u16 s = zig_ret_struct_u16(); + assert_or_panic(s.a == 1); + zig_struct_u16((struct Struct_u16){ .a = 2 }, 3); +} + +struct Struct_u16_u16 { + uint16_t a, b; +}; + +struct Struct_u16_u16 zig_ret_struct_u16_u16(void); +void zig_struct_u16_u16(struct Struct_u16_u16, size_t); + +struct Struct_u16_u16 c_ret_struct_u16_u16(void) { + return (struct Struct_u16_u16){ .a = 6, .b = 7 }; +} +void c_struct_u16_u16(struct Struct_u16_u16 s, size_t i) { + assert_or_panic(s.a == 8); + assert_or_panic(s.b == 9); + assert_or_panic(i == 10); +} +void c_test_struct_u16_u16(void) { + struct Struct_u16_u16 s = zig_ret_struct_u16_u16(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_u16_u16((struct Struct_u16_u16){ .a = 3, .b = 4 }, 5); +} + +struct Struct_u16_u16_u16 { + uint16_t a, b, c; +}; + +struct Struct_u16_u16_u16 zig_ret_struct_u16_u16_u16(void); +void zig_struct_u16_u16_u16(struct Struct_u16_u16_u16, size_t); + +struct Struct_u16_u16_u16 c_ret_struct_u16_u16_u16(void) { + return (struct Struct_u16_u16_u16){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_u16_u16_u16(struct Struct_u16_u16_u16 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_u16_u16_u16(void) { + struct Struct_u16_u16_u16 s = zig_ret_struct_u16_u16_u16(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_u16_u16_u16((struct Struct_u16_u16_u16){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_u16_u16_u16_u16 { + uint16_t a, b, c, d; +}; + +struct Struct_u16_u16_u16_u16 zig_ret_struct_u16_u16_u16_u16(void); +void zig_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16, size_t); + +struct Struct_u16_u16_u16_u16 c_ret_struct_u16_u16_u16_u16(void) { + return (struct Struct_u16_u16_u16_u16){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_u16_u16_u16_u16(void) { + struct Struct_u16_u16_u16_u16 s = zig_ret_struct_u16_u16_u16_u16(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_u16_u16_u16_u16((struct Struct_u16_u16_u16_u16){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_u32 { + uint32_t a; +}; + +struct Struct_u32 zig_ret_struct_u32(void); +void zig_struct_u32(struct Struct_u32, size_t); + +struct Struct_u32 c_ret_struct_u32(void) { + return (struct Struct_u32){ .a = 4 }; +} +void c_struct_u32(struct Struct_u32 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_u32(void) { + struct Struct_u32 s = zig_ret_struct_u32(); + assert_or_panic(s.a == 1); + zig_struct_u32((struct Struct_u32){ .a = 2 }, 3); +} + +struct Struct_u32_u32 { + uint32_t a, b; +}; + +struct Struct_u32_u32 zig_ret_struct_u32_u32(void); +void zig_struct_u32_u32(struct Struct_u32_u32, size_t); + +struct Struct_u32_u32 c_ret_struct_u32_u32(void) { + return (struct Struct_u32_u32){ .a = 6, .b = 7 }; +} +void c_struct_u32_u32(struct Struct_u32_u32 s, size_t i) { + assert_or_panic(s.a == 8); + assert_or_panic(s.b == 9); + assert_or_panic(i == 10); +} +void c_test_struct_u32_u32(void) { + struct Struct_u32_u32 s = zig_ret_struct_u32_u32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_u32_u32((struct Struct_u32_u32){ .a = 3, .b = 4 }, 5); +} + +struct Struct_u32_u32_u32 { + uint32_t a, b, c; +}; + +struct Struct_u32_u32_u32 zig_ret_struct_u32_u32_u32(void); +void zig_struct_u32_u32_u32(struct Struct_u32_u32_u32, size_t); + +struct Struct_u32_u32_u32 c_ret_struct_u32_u32_u32(void) { + return (struct Struct_u32_u32_u32){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_u32_u32_u32(struct Struct_u32_u32_u32 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_u32_u32_u32(void) { + struct Struct_u32_u32_u32 s = zig_ret_struct_u32_u32_u32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_u32_u32_u32((struct Struct_u32_u32_u32){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_u32_u32_u32_u32 { + uint32_t a, b, c, d; +}; + +struct Struct_u32_u32_u32_u32 zig_ret_struct_u32_u32_u32_u32(void); +void zig_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32, size_t); + +struct Struct_u32_u32_u32_u32 c_ret_struct_u32_u32_u32_u32(void) { + return (struct Struct_u32_u32_u32_u32){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_u32_u32_u32_u32(void) { + struct Struct_u32_u32_u32_u32 s = zig_ret_struct_u32_u32_u32_u32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_u32_u32_u32_u32((struct Struct_u32_u32_u32_u32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_u64 { + uint64_t a; +}; + +struct Struct_u64 zig_ret_struct_u64(void); +void zig_struct_u64(struct Struct_u64, size_t); + +struct Struct_u64 c_ret_struct_u64(void) { + return (struct Struct_u64){ .a = 4 }; +} +void c_struct_u64(struct Struct_u64 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_u64(void) { + struct Struct_u64 s = zig_ret_struct_u64(); + assert_or_panic(s.a == 1); + zig_struct_u64((struct Struct_u64){ .a = 2 }, 3); +} + +struct Struct_u64_u64 { + uint64_t a; + uint64_t b; +}; + +struct Struct_u64_u64 zig_ret_struct_u64_u64(void); +void zig_struct_u64_u64(struct Struct_u64_u64, size_t); +void zig_1_struct_u64_u64(size_t, struct Struct_u64_u64, size_t); +void zig_2_struct_u64_u64(size_t, size_t, struct Struct_u64_u64, size_t); +void zig_3_struct_u64_u64(size_t, size_t, size_t, struct Struct_u64_u64, size_t); +void zig_4_struct_u64_u64(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); +void zig_5_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); +void zig_6_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); +void zig_7_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); +void zig_8_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t); + +struct Struct_u64_u64 c_ret_struct_u64_u64(void) { + return (struct Struct_u64_u64){ .a = 21, .b = 22 }; +} +void c_struct_u64_u64(struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 23); + assert_or_panic(s.b == 24); + assert_or_panic(i == 1); +} +void c_1_struct_u64_u64(size_t a0, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 25); + assert_or_panic(s.b == 26); + assert_or_panic(i == 2); +} +void c_2_struct_u64_u64(size_t a0, size_t a1, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 27); + assert_or_panic(s.b == 28); + assert_or_panic(i == 3); +} +void c_3_struct_u64_u64(size_t a0, size_t a1, size_t a2, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 29); + assert_or_panic(s.b == 30); + assert_or_panic(i == 4); +} +void c_4_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 31); + assert_or_panic(s.b == 32); + assert_or_panic(i == 5); +} +void c_5_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 33); + assert_or_panic(s.b == 34); + assert_or_panic(i == 6); +} +void c_6_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 35); + assert_or_panic(s.b == 36); + assert_or_panic(i == 7); +} +void c_7_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 37); + assert_or_panic(s.b == 38); + assert_or_panic(i == 8); +} +void c_8_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, struct Struct_u64_u64 s, size_t i) { + assert_or_panic(s.a == 39); + assert_or_panic(s.b == 40); + assert_or_panic(i == 9); +} +void c_test_struct_u64_u64(void) { + struct Struct_u64_u64 s = zig_ret_struct_u64_u64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_u64_u64((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1); + zig_1_struct_u64_u64(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2); + zig_2_struct_u64_u64(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3); + zig_3_struct_u64_u64(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4); + zig_4_struct_u64_u64(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5); + zig_5_struct_u64_u64(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6); + zig_6_struct_u64_u64(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7); + zig_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8); + zig_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9); +} + +struct Struct_u64_u64_u64 { + uint64_t a, b, c; +}; + +struct Struct_u64_u64_u64 zig_ret_struct_u64_u64_u64(void); +void zig_struct_u64_u64_u64(struct Struct_u64_u64_u64, size_t); + +struct Struct_u64_u64_u64 c_ret_struct_u64_u64_u64(void) { + return (struct Struct_u64_u64_u64){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_u64_u64_u64(struct Struct_u64_u64_u64 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_u64_u64_u64(void) { + struct Struct_u64_u64_u64 s = zig_ret_struct_u64_u64_u64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_u64_u64_u64((struct Struct_u64_u64_u64){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_u64_u64_u64_u64 { + uint64_t a, b, c, d; +}; + +struct Struct_u64_u64_u64_u64 zig_ret_struct_u64_u64_u64_u64(void); +void zig_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64, size_t); + +struct Struct_u64_u64_u64_u64 c_ret_struct_u64_u64_u64_u64(void) { + return (struct Struct_u64_u64_u64_u64){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_u64_u64_u64_u64(void) { + struct Struct_u64_u64_u64_u64 s = zig_ret_struct_u64_u64_u64_u64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_u64_u64_u64_u64((struct Struct_u64_u64_u64_u64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_f32 { + float a; +}; + +struct Struct_f32 zig_ret_struct_f32(void); +void zig_struct_f32(struct Struct_f32, size_t); + +struct Struct_f32 c_ret_struct_f32(void) { + return (struct Struct_f32){ .a = 4 }; +} +void c_struct_f32(struct Struct_f32 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_f32(void) { + struct Struct_f32 s = zig_ret_struct_f32(); + assert_or_panic(s.a == 1); + zig_struct_f32((struct Struct_f32){ .a = 2 }, 3); +} + +struct Struct_f32_f32 { + float a, b; +}; + +struct Struct_f32_f32 zig_ret_struct_f32_f32(void); +void zig_struct_f32_f32(struct Struct_f32_f32, size_t); + +struct Struct_f32_f32 c_ret_struct_f32_f32(void) { + return (struct Struct_f32_f32){ .a = 6, .b = 7 }; +} +void c_struct_f32_f32(struct Struct_f32_f32 s, size_t i) { + assert_or_panic(s.a == 8); + assert_or_panic(s.b == 9); + assert_or_panic(i == 10); +} +void c_test_struct_f32_f32(void) { + struct Struct_f32_f32 s = zig_ret_struct_f32_f32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_f32_f32((struct Struct_f32_f32){ .a = 3, .b = 4 }, 5); +} + +struct Struct_f32_f32_f32 { + float a, b, c; +}; + +struct Struct_f32_f32_f32 zig_ret_struct_f32_f32_f32(void); +void zig_struct_f32_f32_f32(struct Struct_f32_f32_f32, size_t); + +struct Struct_f32_f32_f32 c_ret_struct_f32_f32_f32(void) { + return (struct Struct_f32_f32_f32){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_f32_f32_f32(struct Struct_f32_f32_f32 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_f32_f32_f32(void) { + struct Struct_f32_f32_f32 s = zig_ret_struct_f32_f32_f32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_f32_f32_f32((struct Struct_f32_f32_f32){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_f32_f32_f32_f32 { + float a, b, c, d; +}; + +struct Struct_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32(void); +void zig_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32, size_t); + +struct Struct_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32(void) { + return (struct Struct_f32_f32_f32_f32){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_f32_f32_f32_f32(void) { + struct Struct_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_f32_f32_f32_f32_f32 { + float a, b, c, d, e; +}; + +struct Struct_f32_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32_f32(void); +void zig_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32, size_t); + +struct Struct_f32_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32_f32(void) { + return (struct Struct_f32_f32_f32_f32_f32){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 }; +} +void c_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32 s, size_t i) { + assert_or_panic(s.a == 17); + assert_or_panic(s.b == 18); + assert_or_panic(s.c == 19); + assert_or_panic(s.d == 20); + assert_or_panic(s.e == 21); + assert_or_panic(i == 22); +} +void c_test_struct_f32_f32_f32_f32_f32(void) { + struct Struct_f32_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32_f32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + assert_or_panic(s.e == 5); + zig_struct_f32_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32_f32){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11); +} + +struct Struct_f32a8 { + alignas(8) float a; +}; + +struct Struct_f32a8 zig_ret_struct_f32a8(void); +void zig_struct_f32a8(struct Struct_f32a8, float); + +struct Struct_f32a8 c_ret_struct_f32a8(void) { + return (struct Struct_f32a8){ .a = 4.125f }; +} +void c_struct_f32a8(struct Struct_f32a8 s, float f) { + assert_or_panic(s.a == 5.375f); + assert_or_panic(f == 6.5f); +} +void c_test_struct_f32a8(void) { + struct Struct_f32a8 s = zig_ret_struct_f32a8(); + assert_or_panic(s.a == 1.25f); + zig_struct_f32a8((struct Struct_f32a8){ .a = 2.75f }, 3.5f); +} + +struct Struct_f32a8_f32a8 { + alignas(8) float a; + alignas(8) float b; +}; + +struct Struct_f32a8_f32a8 zig_ret_struct_f32a8_f32a8(void); +void zig_struct_f32a8_f32a8(struct Struct_f32a8_f32a8, float); + +struct Struct_f32a8_f32a8 c_ret_struct_f32a8_f32a8(void) { + return (struct Struct_f32a8_f32a8){ .a = 6.625f, .b = 7.875f }; +} +void c_struct_f32a8_f32a8(struct Struct_f32a8_f32a8 s, float f) { + assert_or_panic(s.a == 8.0625f); + assert_or_panic(s.b == 9.1875f); + assert_or_panic(f == 10.5f); +} +void c_test_struct_f32a8_f32a8(void) { + struct Struct_f32a8_f32a8 s = zig_ret_struct_f32a8_f32a8(); + assert_or_panic(s.a == 1.25f); + assert_or_panic(s.b == 2.75f); + zig_struct_f32a8_f32a8((struct Struct_f32a8_f32a8){ .a = 3.125f, .b = 4.375f }, 5.5f); +} + +struct Struct_f32f32_f32 { + struct { + float b, c; + } a; + float d; +}; + +struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void); +void zig_struct_f32f32_f32(struct Struct_f32f32_f32); + +struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) { + return (struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f }; +} +void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) { + assert_or_panic(s.a.b == 1.0f); + assert_or_panic(s.a.c == 2.0f); + assert_or_panic(s.d == 3.0f); +} +void c_test_struct_f32f32_f32(void) { + struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32(); + assert_or_panic(s.a.b == 1.0f); + assert_or_panic(s.a.c == 2.0f); + assert_or_panic(s.d == 3.0f); + zig_struct_f32f32_f32((struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f }); +} + +struct Struct_f32_f32f32 { + float a; + struct { + float c, d; + } b; +}; + +struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void); +void zig_struct_f32_f32f32(struct Struct_f32_f32f32); + +struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) { + return (struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } }; +} +void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) { + assert_or_panic(s.a == 1.0f); + assert_or_panic(s.b.c == 2.0f); + assert_or_panic(s.b.d == 3.0f); +} +void c_test_struct_f32_f32f32(void) { + struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32(); + assert_or_panic(s.a == 1.0f); + assert_or_panic(s.b.c == 2.0f); + assert_or_panic(s.b.d == 3.0f); + zig_struct_f32_f32f32((struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } }); +} + +struct Struct_f64 { + double a; +}; + +struct Struct_f64 zig_ret_struct_f64(void); +void zig_struct_f64(struct Struct_f64, size_t); + +struct Struct_f64 c_ret_struct_f64(void) { + return (struct Struct_f64){ .a = 4 }; +} +void c_struct_f64(struct Struct_f64 s, size_t i) { + assert_or_panic(s.a == 5); + assert_or_panic(i == 6); +} +void c_test_struct_f64(void) { + struct Struct_f64 s = zig_ret_struct_f64(); + assert_or_panic(s.a == 1); + zig_struct_f64((struct Struct_f64){ .a = 2 }, 3); +} + +struct Struct_f64_f64 { + double a, b; +}; + +struct Struct_f64_f64 zig_ret_struct_f64_f64(void); +void zig_struct_f64_f64(struct Struct_f64_f64, size_t); + +struct Struct_f64_f64 c_ret_struct_f64_f64(void) { + return (struct Struct_f64_f64){ .a = 6, .b = 7 }; +} +void c_struct_f64_f64(struct Struct_f64_f64 s, size_t i) { + assert_or_panic(s.a == 8); + assert_or_panic(s.b == 9); + assert_or_panic(i == 10); +} +void c_test_struct_f64_f64(void) { + struct Struct_f64_f64 s = zig_ret_struct_f64_f64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + zig_struct_f64_f64((struct Struct_f64_f64){ .a = 3, .b = 4 }, 5); +} + +struct Struct_f64_f64_f64 { + double a, b, c; +}; -void zig_vector_2_bool(Vector2Bool vec); -void zig_vector_4_bool(Vector4Bool vec); -void zig_vector_8_bool(Vector8Bool vec); -void zig_vector_16_bool(Vector16Bool vec); -void zig_vector_32_bool(Vector32Bool vec); -void zig_vector_64_bool(Vector64Bool vec); -void zig_vector_128_bool(Vector128Bool vec); -void zig_vector_256_bool(Vector256Bool vec); -void zig_vector_512_bool(Vector512Bool vec); - -Vector2Bool zig_ret_vector_2_bool(void); -Vector4Bool zig_ret_vector_4_bool(void); -Vector8Bool zig_ret_vector_8_bool(void); -Vector16Bool zig_ret_vector_16_bool(void); -Vector32Bool zig_ret_vector_32_bool(void); -Vector64Bool zig_ret_vector_64_bool(void); -Vector128Bool zig_ret_vector_128_bool(void); -Vector256Bool zig_ret_vector_256_bool(void); -Vector512Bool zig_ret_vector_512_bool(void); +struct Struct_f64_f64_f64 zig_ret_struct_f64_f64_f64(void); +void zig_struct_f64_f64_f64(struct Struct_f64_f64_f64, size_t); +struct Struct_f64_f64_f64 c_ret_struct_f64_f64_f64(void) { + return (struct Struct_f64_f64_f64){ .a = 8, .b = 9, .c = 10 }; +} +void c_struct_f64_f64_f64(struct Struct_f64_f64_f64 s, size_t i) { + assert_or_panic(s.a == 11); + assert_or_panic(s.b == 12); + assert_or_panic(s.c == 13); + assert_or_panic(i == 14); +} +void c_test_struct_f64_f64_f64(void) { + struct Struct_f64_f64_f64 s = zig_ret_struct_f64_f64_f64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + zig_struct_f64_f64_f64((struct Struct_f64_f64_f64){ .a = 4, .b = 5, .c = 6 }, 7); +} + +struct Struct_f64_f64_f64_f64 { + double a, b, c, d; +}; + +struct Struct_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64(void); +void zig_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64, size_t); + +struct Struct_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64(void) { + return (struct Struct_f64_f64_f64_f64){ .a = 10, .b = 11, .c = 12, .d = 13 }; +} +void c_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64 s, size_t i) { + assert_or_panic(s.a == 14); + assert_or_panic(s.b == 15); + assert_or_panic(s.c == 16); + assert_or_panic(s.d == 17); + assert_or_panic(i == 18); +} +void c_test_struct_f64_f64_f64_f64(void) { + struct Struct_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + zig_struct_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9); +} + +struct Struct_f64_f64_f64_f64_f64 { + double a, b, c, d, e; +}; + +struct Struct_f64_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64_f64(void); +void zig_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64, size_t); + +struct Struct_f64_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64_f64(void) { + return (struct Struct_f64_f64_f64_f64_f64){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 }; +} +void c_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64 s, size_t i) { + assert_or_panic(s.a == 17); + assert_or_panic(s.b == 18); + assert_or_panic(s.c == 19); + assert_or_panic(s.d == 20); + assert_or_panic(s.e == 21); + assert_or_panic(i == 22); +} +void c_test_struct_f64_f64_f64_f64_f64(void) { + struct Struct_f64_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64_f64(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b == 2); + assert_or_panic(s.c == 3); + assert_or_panic(s.d == 4); + assert_or_panic(s.e == 5); + zig_struct_f64_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64_f64){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11); +} + +struct Struct_u32_Union_u32_u32u32 { + uint32_t a; + union { + struct { + uint32_t d, e; + } c; + } b; +}; + +struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void); +void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32); + +struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) { + struct Struct_u32_Union_u32_u32u32 s; + s.a = 1; + s.b.c.d = 2; + s.b.c.e = 3; + return s; +} +void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) { + assert_or_panic(s.a == 1); + assert_or_panic(s.b.c.d == 2); + assert_or_panic(s.b.c.e == 3); +} +void c_test_struct_u32_union_u32_u32u32(void) { + struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32(); + assert_or_panic(s.a == 1); + assert_or_panic(s.b.c.d == 2); + assert_or_panic(s.b.c.e == 3); + zig_struct_u32_union_u32_u32u32(s); +} + +struct Struct_i32_i32 { + int32_t a; + int32_t b; +}; + +void zig_struct_i32_i32(struct Struct_i32_i32); + +struct BigStruct { + uint64_t a; + uint64_t b; + uint64_t c; + uint64_t d; + uint8_t e; +}; + +void zig_big_struct(struct BigStruct); + +union BigUnion { + struct BigStruct a; +}; + +void zig_big_union(union BigUnion); + +struct MedStructMixed { + uint32_t a; + float b; + float c; + uint32_t d; +}; + +void zig_med_struct_mixed(struct MedStructMixed); +struct MedStructMixed zig_ret_med_struct_mixed(); + +void zig_small_packed_struct(uint8_t); +#ifndef ZIG_NO_I128 +void zig_big_packed_struct(__int128); #endif -typedef struct Vector3 { - float x; - float y; - float z; -} Vector3; - -typedef struct Vector5 { - float x; - float y; - float z; - float w; - float q; -} Vector5; - -typedef struct Rect { - uint32_t left; - uint32_t right; - uint32_t top; - uint32_t bottom; -} Rect; - -void zig_multiple_struct_ints(struct Rect, struct Rect); - -typedef struct FloatRect { - float left; - float right; - float top; - float bottom; -} FloatRect; - -void zig_multiple_struct_floats(struct FloatRect, struct FloatRect); +struct SplitStructInts { + uint64_t a; + uint8_t b; + uint32_t c; +}; +void zig_split_struct_ints(struct SplitStructInts); + +struct SplitStructMixed { + uint64_t a; + uint8_t b; + float c; +}; +void zig_split_struct_mixed(struct SplitStructMixed); +struct SplitStructMixed zig_ret_split_struct_mixed(); + +struct BigStruct zig_big_struct_both(struct BigStruct); void run_c_tests(void) { zig_u8(0xff); @@ -2849,202 +15374,34 @@ void run_c_tests(void) { } #endif -#if !defined(__mips64) -#if !defined(ZIG_PPC32) -#if !defined(__s390x__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_u8 s = zig_ret_struct_u8(); - assert_or_panic(s.a == 1); - zig_struct_u8((struct Struct_u8){ .a = 2 }, 3); - } -#endif -#endif -#endif -#endif - -#if !defined(__mips64) -#if !defined(ZIG_PPC32) -#if !defined(__s390x__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_u16 s = zig_ret_struct_u16(); - assert_or_panic(s.a == 7); - zig_struct_u16((struct Struct_u16){ .a = 8 }, 9); - } -#endif -#endif -#endif -#endif - -#if !defined(__mips64) -#if !defined(ZIG_PPC32) -#if !defined(__s390x__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_u32 s = zig_ret_struct_u32(); - assert_or_panic(s.a == 13); - zig_struct_u32((struct Struct_u32){ .a = 14 }, 15); - } -#endif -#endif -#endif -#endif - -#if !defined(ZIG_PPC32) -#if !defined(ZIG_RISCV32) -#if !defined(__s390x__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_u64 s = zig_ret_struct_u64(); - assert_or_panic(s.a == 19); - zig_struct_u64((struct Struct_u64){ .a = 20 }, 21); - } -#endif -#endif -#endif -#endif - -#if !defined(ZIG_PPC32) && !defined(__hexagon__) && !defined(__s390x__) - { - struct Struct_u64_u64 s = zig_ret_struct_u64_u64(); - assert_or_panic(s.a == 1); - assert_or_panic(s.b == 2); - zig_struct_u64_u64_0((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1); - zig_struct_u64_u64_1(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2); - zig_struct_u64_u64_2(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3); - zig_struct_u64_u64_3(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4); - zig_struct_u64_u64_4(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5); - zig_struct_u64_u64_5(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6); - zig_struct_u64_u64_6(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7); - zig_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8); - zig_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9); - } - -#if !defined(__mips64__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_f32 s = zig_ret_struct_f32(); - assert_or_panic(s.a == 2.5f); - zig_struct_f32((struct Struct_f32){ .a = 2.5f }); - } -#endif -#endif - -#if !(defined(__arm__) && defined(__SOFTFP__)) -#if !defined(ZIG_RISCV32) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_f64 s = zig_ret_struct_f64(); - assert_or_panic(s.a == 2.5); - zig_struct_f64((struct Struct_f64){ .a = 2.5 }); - } -#endif -#endif -#endif - -#if !defined(__arm__) -#if !defined(__loongarch__) -#if !defined(__mips64__) -#if !defined(__powerpc__) -#if !defined(ZIG_RISCV32) -#if !defined(__s390x__) -#if !defined(__i386__) - { - struct Struct_f32a8 s = zig_ret_struct_f32a8(); - assert_or_panic(s.a == 1.25f); - zig_struct_f32a8((struct Struct_f32a8){ .a = 2.75f }, 3.5f); - } -#endif -#endif -#endif -#endif -#endif -#endif -#endif - -#if !defined(__arm__) -#if !defined(__loongarch__) -#if !defined(__mips64__) -#if !defined(__powerpc__) -#if !defined(__riscv) -#if !defined(__s390x__) -#if !defined(__i386__) - { - struct Struct_f32a8_f32a8 s = zig_ret_struct_f32a8_f32a8(); - assert_or_panic(s.a == 1.25f); - assert_or_panic(s.b == 2.75f); - zig_struct_f32a8_f32a8((struct Struct_f32a8_f32a8){ .a = 3.125f, .b = 4.375f }, 5.5f); - } -#endif -#endif -#endif -#endif -#endif -#endif -#endif - -#if !(defined(__arm__) && defined(__SOFTFP__)) -#if !defined(__loongarch__) && !defined(__mips64__) - { - struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32(); - assert_or_panic(s.a.b == 1.0f); - assert_or_panic(s.a.c == 2.0f); - assert_or_panic(s.d == 3.0f); - zig_struct_f32f32_f32((struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f }); - } - - { - struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32(); - assert_or_panic(s.a == 1.0f); - assert_or_panic(s.b.c == 2.0f); - assert_or_panic(s.b.d == 3.0f); - zig_struct_f32_f32f32((struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } }); - } -#endif -#endif - -#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__) -#if !(defined(_WIN32) && defined(__i386__)) - { - struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32(); - assert_or_panic(s.a == 1); - assert_or_panic(s.b.c.d == 2); - assert_or_panic(s.b.c.e == 3); - zig_struct_u32_union_u32_u32u32(s); - } - +#if !(defined(__i386__) && defined(_WIN32)) +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct Struct_i32_i32 s = {1, 2}; zig_struct_i32_i32(s); } #endif #endif +#endif +#endif +#endif -#if !defined(__powerpc64__) && !defined(__loongarch__) && !defined(__mips64__) +#ifndef __hexagon__ +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct BigStruct s = {1, 2, 3, 4, 5}; zig_big_struct(s); } #endif #endif - -#if !defined __i386__ && !defined __arm__ && \ - !defined __powerpc__ && !defined(__loongarch__) && \ - !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__) - { - struct SmallStructInts s = {1, 2, 3, 4}; - zig_small_struct_ints(s); - } #endif - -#if !defined __arm__ && \ - !defined __powerpc__ && !defined(__loongarch__) && \ - !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__) - { - struct MedStructInts s = {1, 2, 3}; - zig_med_struct_ints(s); - } +#endif #endif #ifndef ZIG_NO_I128 @@ -3065,34 +15422,60 @@ void run_c_tests(void) { zig_small_packed_struct(s); } -#if !defined __i386__ && !defined __arm__ && \ - !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \ - !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__) +#ifndef __hexagon__ +#ifndef __i386__ +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct SplitStructInts s = {1234, 100, 1337}; zig_split_struct_ints(s); } #endif +#endif +#endif +#endif +#endif +#endif -#if !defined __arm__ && !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \ - !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__) +#ifndef __hexagon__ +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct MedStructMixed s = {1234, 100.0f, 1337.0f}; zig_med_struct_mixed(s); } #endif +#endif +#endif +#endif +#endif -#if !defined __i386__ && !defined __arm__ && \ - !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \ - !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__) +#ifndef __hexagon__ +#ifndef __i386__ +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct SplitStructMixed s = {1234, 100, 1337.0f}; zig_split_struct_mixed(s); } #endif +#endif +#endif +#endif +#endif +#endif -#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \ - !defined(__s390x__) +#ifndef __hexagon__ +#ifndef __loongarch__ +#ifndef ZIG_MIPS64 +#ifndef __powerpc__ +#ifndef __s390x__ { struct BigStruct s = {30, 31, 32, 33, 34}; struct BigStruct res = zig_big_struct_both(s); @@ -3103,23 +15486,9 @@ void run_c_tests(void) { assert_or_panic(res.e == 24); } #endif - -#if !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && !defined(__mips64__) && \ - !defined(__hexagon__) && !defined(__s390x__) - { - struct Rect r1 = {1, 21, 16, 4}; - struct Rect r2 = {178, 189, 21, 15}; - zig_multiple_struct_ints(r1, r2); - } #endif - -#if !defined ZIG_PPC32 && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \ - !defined(__s390x__) - { - struct FloatRect r1 = {1, 21, 16, 4}; - struct FloatRect r2 = {178, 189, 21, 15}; - zig_multiple_struct_floats(r1, r2); - } +#endif +#endif #endif { @@ -3135,2107 +15504,6 @@ void run_c_tests(void) { assert_or_panic(zig_ret_i32() == -1); assert_or_panic(zig_ret_i64() == -1); } - -#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32) - { - zig_vector_2_bool((Vector2Bool){ - false, - true, - }); - - Vector2Bool vec = zig_ret_vector_2_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == false); - } - { - zig_vector_4_bool((Vector4Bool){ - false, - false, - false, - false, - }); - - Vector4Bool vec = zig_ret_vector_4_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == true); - assert_or_panic(vec[3] == true); - } - { - zig_vector_8_bool((Vector8Bool){ - true, - true, - false, - true, - false, - true, - true, - false, - }); - - Vector8Bool vec = zig_ret_vector_8_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == false); - assert_or_panic(vec[2] == false); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == true); - assert_or_panic(vec[5] == false); - assert_or_panic(vec[6] == false); - assert_or_panic(vec[7] == false); - } - { - zig_vector_16_bool((Vector16Bool){ - true, - false, - true, - true, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - }); - - Vector16Bool vec = zig_ret_vector_16_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == false); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == false); - assert_or_panic(vec[5] == true); - assert_or_panic(vec[6] == false); - assert_or_panic(vec[7] == false); - assert_or_panic(vec[8] == true); - assert_or_panic(vec[9] == false); - assert_or_panic(vec[10] == false); - assert_or_panic(vec[11] == false); - assert_or_panic(vec[12] == false); - assert_or_panic(vec[13] == true); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == false); - } - { - zig_vector_32_bool((Vector32Bool){ - false, - false, - false, - true, - true, - false, - false, - true, - false, - true, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - }); - - Vector32Bool vec = zig_ret_vector_32_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == false); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == true); - assert_or_panic(vec[5] == false); - assert_or_panic(vec[6] == true); - assert_or_panic(vec[7] == true); - assert_or_panic(vec[8] == true); - assert_or_panic(vec[9] == true); - assert_or_panic(vec[10] == true); - assert_or_panic(vec[11] == true); - assert_or_panic(vec[12] == false); - assert_or_panic(vec[13] == false); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == false); - assert_or_panic(vec[16] == false); - assert_or_panic(vec[17] == false); - assert_or_panic(vec[18] == true); - assert_or_panic(vec[19] == true); - assert_or_panic(vec[20] == true); - assert_or_panic(vec[21] == false); - assert_or_panic(vec[22] == true); - assert_or_panic(vec[23] == false); - assert_or_panic(vec[24] == true); - assert_or_panic(vec[25] == false); - assert_or_panic(vec[26] == false); - assert_or_panic(vec[27] == true); - assert_or_panic(vec[28] == false); - assert_or_panic(vec[29] == false); - assert_or_panic(vec[30] == true); - assert_or_panic(vec[31] == true); - } - { - zig_vector_64_bool((Vector64Bool){ - true, - true, - false, - true, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - true, - false, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - true, - false, - false, - false, - false, - false, - true, - false, - false, - true, - true, - false, - false, - false, - true, - true, - true, - true, - }); - - Vector64Bool vec = zig_ret_vector_64_bool(); - assert_or_panic(vec[0] == true); - assert_or_panic(vec[1] == false); - assert_or_panic(vec[2] == true); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == false); - assert_or_panic(vec[5] == true); - assert_or_panic(vec[6] == false); - assert_or_panic(vec[7] == true); - assert_or_panic(vec[8] == true); - assert_or_panic(vec[9] == false); - assert_or_panic(vec[10] == true); - assert_or_panic(vec[11] == false); - assert_or_panic(vec[12] == true); - assert_or_panic(vec[13] == false); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == true); - assert_or_panic(vec[16] == false); - assert_or_panic(vec[17] == false); - assert_or_panic(vec[18] == true); - assert_or_panic(vec[19] == true); - assert_or_panic(vec[20] == false); - assert_or_panic(vec[21] == false); - assert_or_panic(vec[22] == true); - assert_or_panic(vec[23] == false); - assert_or_panic(vec[24] == false); - assert_or_panic(vec[25] == true); - assert_or_panic(vec[26] == true); - assert_or_panic(vec[27] == true); - assert_or_panic(vec[28] == true); - assert_or_panic(vec[29] == true); - assert_or_panic(vec[30] == false); - assert_or_panic(vec[31] == false); - assert_or_panic(vec[32] == true); - assert_or_panic(vec[33] == true); - assert_or_panic(vec[34] == true); - assert_or_panic(vec[35] == true); - assert_or_panic(vec[36] == false); - assert_or_panic(vec[37] == true); - assert_or_panic(vec[38] == false); - assert_or_panic(vec[39] == true); - assert_or_panic(vec[40] == true); - assert_or_panic(vec[41] == true); - assert_or_panic(vec[42] == true); - assert_or_panic(vec[43] == true); - assert_or_panic(vec[44] == false); - assert_or_panic(vec[45] == false); - assert_or_panic(vec[46] == false); - assert_or_panic(vec[47] == true); - assert_or_panic(vec[48] == true); - assert_or_panic(vec[49] == true); - assert_or_panic(vec[50] == false); - assert_or_panic(vec[51] == true); - assert_or_panic(vec[52] == true); - assert_or_panic(vec[53] == true); - assert_or_panic(vec[54] == false); - assert_or_panic(vec[55] == false); - assert_or_panic(vec[56] == false); - assert_or_panic(vec[57] == true); - assert_or_panic(vec[58] == false); - assert_or_panic(vec[59] == false); - assert_or_panic(vec[60] == true); - assert_or_panic(vec[61] == false); - assert_or_panic(vec[62] == true); - assert_or_panic(vec[63] == false); - } - { - zig_vector_128_bool((Vector128Bool){ - true, - true, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - false, - false, - true, - false, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - false, - true, - true, - false, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - true, - true, - false, - true, - true, - true, - true, - true, - true, - false, - true, - true, - true, - true, - true, - true, - false, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - false, - true, - false, - }); - - Vector128Bool vec = zig_ret_vector_128_bool(); - assert_or_panic(vec[0] == true); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == false); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == false); - assert_or_panic(vec[5] == true); - assert_or_panic(vec[6] == true); - assert_or_panic(vec[7] == false); - assert_or_panic(vec[8] == false); - assert_or_panic(vec[9] == true); - assert_or_panic(vec[10] == false); - assert_or_panic(vec[11] == false); - assert_or_panic(vec[12] == false); - assert_or_panic(vec[13] == true); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == true); - assert_or_panic(vec[16] == true); - assert_or_panic(vec[17] == false); - assert_or_panic(vec[18] == false); - assert_or_panic(vec[19] == true); - assert_or_panic(vec[20] == true); - assert_or_panic(vec[21] == true); - assert_or_panic(vec[22] == true); - assert_or_panic(vec[23] == true); - assert_or_panic(vec[24] == false); - assert_or_panic(vec[25] == false); - assert_or_panic(vec[26] == true); - assert_or_panic(vec[27] == true); - assert_or_panic(vec[28] == true); - assert_or_panic(vec[29] == false); - assert_or_panic(vec[30] == false); - assert_or_panic(vec[31] == true); - assert_or_panic(vec[32] == true); - assert_or_panic(vec[33] == false); - assert_or_panic(vec[34] == true); - assert_or_panic(vec[35] == true); - assert_or_panic(vec[36] == true); - assert_or_panic(vec[37] == false); - assert_or_panic(vec[38] == true); - assert_or_panic(vec[39] == true); - assert_or_panic(vec[40] == true); - assert_or_panic(vec[41] == false); - assert_or_panic(vec[42] == true); - assert_or_panic(vec[43] == true); - assert_or_panic(vec[44] == false); - assert_or_panic(vec[45] == false); - assert_or_panic(vec[46] == false); - assert_or_panic(vec[47] == true); - assert_or_panic(vec[48] == false); - assert_or_panic(vec[49] == false); - assert_or_panic(vec[50] == false); - assert_or_panic(vec[51] == false); - assert_or_panic(vec[52] == true); - assert_or_panic(vec[53] == false); - assert_or_panic(vec[54] == true); - assert_or_panic(vec[55] == false); - assert_or_panic(vec[56] == true); - assert_or_panic(vec[57] == false); - assert_or_panic(vec[58] == false); - assert_or_panic(vec[59] == true); - assert_or_panic(vec[60] == true); - assert_or_panic(vec[61] == true); - assert_or_panic(vec[62] == true); - assert_or_panic(vec[63] == true); - assert_or_panic(vec[64] == false); - assert_or_panic(vec[65] == false); - assert_or_panic(vec[66] == false); - assert_or_panic(vec[67] == true); - assert_or_panic(vec[68] == true); - assert_or_panic(vec[69] == false); - assert_or_panic(vec[70] == true); - assert_or_panic(vec[71] == true); - assert_or_panic(vec[72] == false); - assert_or_panic(vec[73] == true); - assert_or_panic(vec[74] == true); - assert_or_panic(vec[75] == false); - assert_or_panic(vec[76] == false); - assert_or_panic(vec[77] == true); - assert_or_panic(vec[78] == false); - assert_or_panic(vec[79] == true); - assert_or_panic(vec[80] == false); - assert_or_panic(vec[81] == false); - assert_or_panic(vec[82] == true); - assert_or_panic(vec[83] == true); - assert_or_panic(vec[84] == false); - assert_or_panic(vec[85] == true); - assert_or_panic(vec[86] == false); - assert_or_panic(vec[87] == false); - assert_or_panic(vec[88] == true); - assert_or_panic(vec[89] == true); - assert_or_panic(vec[90] == true); - assert_or_panic(vec[91] == true); - assert_or_panic(vec[92] == true); - assert_or_panic(vec[93] == false); - assert_or_panic(vec[94] == false); - assert_or_panic(vec[95] == true); - assert_or_panic(vec[96] == false); - assert_or_panic(vec[97] == false); - assert_or_panic(vec[98] == true); - assert_or_panic(vec[99] == true); - assert_or_panic(vec[100] == true); - assert_or_panic(vec[101] == true); - assert_or_panic(vec[102] == true); - assert_or_panic(vec[103] == true); - assert_or_panic(vec[104] == true); - assert_or_panic(vec[105] == false); - assert_or_panic(vec[106] == false); - assert_or_panic(vec[107] == true); - assert_or_panic(vec[108] == false); - assert_or_panic(vec[109] == false); - assert_or_panic(vec[110] == true); - assert_or_panic(vec[111] == false); - assert_or_panic(vec[112] == false); - assert_or_panic(vec[113] == true); - assert_or_panic(vec[114] == false); - assert_or_panic(vec[115] == false); - assert_or_panic(vec[116] == false); - assert_or_panic(vec[117] == false); - assert_or_panic(vec[118] == false); - assert_or_panic(vec[119] == false); - assert_or_panic(vec[120] == true); - assert_or_panic(vec[121] == true); - assert_or_panic(vec[122] == true); - assert_or_panic(vec[123] == false); - assert_or_panic(vec[124] == true); - assert_or_panic(vec[125] == false); - assert_or_panic(vec[126] == false); - assert_or_panic(vec[127] == true); - } - { - zig_vector_256_bool((Vector256Bool){ - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - false, - true, - true, - false, - true, - false, - false, - true, - true, - true, - false, - true, - false, - true, - false, - false, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - true, - true, - true, - false, - false, - true, - true, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - true, - true, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - false, - false, - true, - false, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - false, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - true, - false, - true, - true, - true, - false, - true, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - false, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - false, - false, - true, - true, - true, - true, - }); - - Vector256Bool vec = zig_ret_vector_256_bool(); - assert_or_panic(vec[0] == true); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == true); - assert_or_panic(vec[3] == false); - assert_or_panic(vec[4] == true); - assert_or_panic(vec[5] == false); - assert_or_panic(vec[6] == false); - assert_or_panic(vec[7] == true); - assert_or_panic(vec[8] == false); - assert_or_panic(vec[9] == false); - assert_or_panic(vec[10] == false); - assert_or_panic(vec[11] == false); - assert_or_panic(vec[12] == false); - assert_or_panic(vec[13] == false); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == false); - assert_or_panic(vec[16] == true); - assert_or_panic(vec[17] == false); - assert_or_panic(vec[18] == true); - assert_or_panic(vec[19] == false); - assert_or_panic(vec[20] == false); - assert_or_panic(vec[21] == true); - assert_or_panic(vec[22] == true); - assert_or_panic(vec[23] == false); - assert_or_panic(vec[24] == false); - assert_or_panic(vec[25] == true); - assert_or_panic(vec[26] == true); - assert_or_panic(vec[27] == false); - assert_or_panic(vec[28] == true); - assert_or_panic(vec[29] == true); - assert_or_panic(vec[30] == true); - assert_or_panic(vec[31] == false); - assert_or_panic(vec[32] == true); - assert_or_panic(vec[33] == false); - assert_or_panic(vec[34] == true); - assert_or_panic(vec[35] == false); - assert_or_panic(vec[36] == true); - assert_or_panic(vec[37] == false); - assert_or_panic(vec[38] == true); - assert_or_panic(vec[39] == false); - assert_or_panic(vec[40] == false); - assert_or_panic(vec[41] == false); - assert_or_panic(vec[42] == true); - assert_or_panic(vec[43] == true); - assert_or_panic(vec[44] == true); - assert_or_panic(vec[45] == false); - assert_or_panic(vec[46] == false); - assert_or_panic(vec[47] == false); - assert_or_panic(vec[48] == true); - assert_or_panic(vec[49] == false); - assert_or_panic(vec[50] == true); - assert_or_panic(vec[51] == false); - assert_or_panic(vec[52] == true); - assert_or_panic(vec[53] == false); - assert_or_panic(vec[54] == true); - assert_or_panic(vec[55] == true); - assert_or_panic(vec[56] == false); - assert_or_panic(vec[57] == false); - assert_or_panic(vec[58] == false); - assert_or_panic(vec[59] == true); - assert_or_panic(vec[60] == true); - assert_or_panic(vec[61] == true); - assert_or_panic(vec[62] == false); - assert_or_panic(vec[63] == true); - assert_or_panic(vec[64] == false); - assert_or_panic(vec[65] == true); - assert_or_panic(vec[66] == false); - assert_or_panic(vec[67] == true); - assert_or_panic(vec[68] == true); - assert_or_panic(vec[69] == false); - assert_or_panic(vec[70] == true); - assert_or_panic(vec[71] == false); - assert_or_panic(vec[72] == true); - assert_or_panic(vec[73] == true); - assert_or_panic(vec[74] == false); - assert_or_panic(vec[75] == false); - assert_or_panic(vec[76] == false); - assert_or_panic(vec[77] == false); - assert_or_panic(vec[78] == false); - assert_or_panic(vec[79] == false); - assert_or_panic(vec[80] == false); - assert_or_panic(vec[81] == false); - assert_or_panic(vec[82] == false); - assert_or_panic(vec[83] == true); - assert_or_panic(vec[84] == false); - assert_or_panic(vec[85] == false); - assert_or_panic(vec[86] == false); - assert_or_panic(vec[87] == true); - assert_or_panic(vec[88] == false); - assert_or_panic(vec[89] == true); - assert_or_panic(vec[90] == true); - assert_or_panic(vec[91] == false); - assert_or_panic(vec[92] == false); - assert_or_panic(vec[93] == true); - assert_or_panic(vec[94] == true); - assert_or_panic(vec[95] == false); - assert_or_panic(vec[96] == false); - assert_or_panic(vec[97] == true); - assert_or_panic(vec[98] == false); - assert_or_panic(vec[99] == false); - assert_or_panic(vec[100] == false); - assert_or_panic(vec[101] == false); - assert_or_panic(vec[102] == false); - assert_or_panic(vec[103] == false); - assert_or_panic(vec[104] == false); - assert_or_panic(vec[105] == true); - assert_or_panic(vec[106] == true); - assert_or_panic(vec[107] == false); - assert_or_panic(vec[108] == true); - assert_or_panic(vec[109] == false); - assert_or_panic(vec[110] == true); - assert_or_panic(vec[111] == true); - assert_or_panic(vec[112] == false); - assert_or_panic(vec[113] == false); - assert_or_panic(vec[114] == false); - assert_or_panic(vec[115] == false); - assert_or_panic(vec[116] == false); - assert_or_panic(vec[117] == false); - assert_or_panic(vec[118] == false); - assert_or_panic(vec[119] == true); - assert_or_panic(vec[120] == true); - assert_or_panic(vec[121] == true); - assert_or_panic(vec[122] == false); - assert_or_panic(vec[123] == true); - assert_or_panic(vec[124] == true); - assert_or_panic(vec[125] == false); - assert_or_panic(vec[126] == false); - assert_or_panic(vec[127] == true); - assert_or_panic(vec[128] == true); - assert_or_panic(vec[129] == true); - assert_or_panic(vec[130] == true); - assert_or_panic(vec[131] == true); - assert_or_panic(vec[132] == false); - assert_or_panic(vec[133] == true); - assert_or_panic(vec[134] == true); - assert_or_panic(vec[135] == false); - assert_or_panic(vec[136] == false); - assert_or_panic(vec[137] == true); - assert_or_panic(vec[138] == true); - assert_or_panic(vec[139] == false); - assert_or_panic(vec[140] == true); - assert_or_panic(vec[141] == false); - assert_or_panic(vec[142] == true); - assert_or_panic(vec[143] == false); - assert_or_panic(vec[144] == true); - assert_or_panic(vec[145] == true); - assert_or_panic(vec[146] == true); - assert_or_panic(vec[147] == true); - assert_or_panic(vec[148] == false); - assert_or_panic(vec[149] == false); - assert_or_panic(vec[150] == false); - assert_or_panic(vec[151] == true); - assert_or_panic(vec[152] == false); - assert_or_panic(vec[153] == true); - assert_or_panic(vec[154] == false); - assert_or_panic(vec[155] == true); - assert_or_panic(vec[156] == true); - assert_or_panic(vec[157] == false); - assert_or_panic(vec[158] == true); - assert_or_panic(vec[159] == true); - assert_or_panic(vec[160] == true); - assert_or_panic(vec[161] == true); - assert_or_panic(vec[162] == true); - assert_or_panic(vec[163] == false); - assert_or_panic(vec[164] == false); - assert_or_panic(vec[165] == true); - assert_or_panic(vec[166] == false); - assert_or_panic(vec[167] == true); - assert_or_panic(vec[168] == true); - assert_or_panic(vec[169] == true); - assert_or_panic(vec[170] == true); - assert_or_panic(vec[171] == false); - assert_or_panic(vec[172] == true); - assert_or_panic(vec[173] == true); - assert_or_panic(vec[174] == true); - assert_or_panic(vec[175] == true); - assert_or_panic(vec[176] == true); - assert_or_panic(vec[177] == true); - assert_or_panic(vec[178] == true); - assert_or_panic(vec[179] == false); - assert_or_panic(vec[180] == true); - assert_or_panic(vec[181] == false); - assert_or_panic(vec[182] == false); - assert_or_panic(vec[183] == false); - assert_or_panic(vec[184] == true); - assert_or_panic(vec[185] == false); - assert_or_panic(vec[186] == true); - assert_or_panic(vec[187] == true); - assert_or_panic(vec[188] == false); - assert_or_panic(vec[189] == true); - assert_or_panic(vec[190] == false); - assert_or_panic(vec[191] == true); - assert_or_panic(vec[192] == false); - assert_or_panic(vec[193] == true); - assert_or_panic(vec[194] == false); - assert_or_panic(vec[195] == false); - assert_or_panic(vec[196] == true); - assert_or_panic(vec[197] == true); - assert_or_panic(vec[198] == true); - assert_or_panic(vec[199] == true); - assert_or_panic(vec[200] == true); - assert_or_panic(vec[201] == true); - assert_or_panic(vec[202] == true); - assert_or_panic(vec[203] == false); - assert_or_panic(vec[204] == true); - assert_or_panic(vec[205] == false); - assert_or_panic(vec[206] == false); - assert_or_panic(vec[207] == true); - assert_or_panic(vec[208] == true); - assert_or_panic(vec[209] == false); - assert_or_panic(vec[210] == false); - assert_or_panic(vec[211] == false); - assert_or_panic(vec[212] == true); - assert_or_panic(vec[213] == true); - assert_or_panic(vec[214] == true); - assert_or_panic(vec[215] == false); - assert_or_panic(vec[216] == false); - assert_or_panic(vec[217] == true); - assert_or_panic(vec[218] == true); - assert_or_panic(vec[219] == true); - assert_or_panic(vec[220] == true); - assert_or_panic(vec[221] == false); - assert_or_panic(vec[222] == true); - assert_or_panic(vec[223] == false); - assert_or_panic(vec[224] == true); - assert_or_panic(vec[225] == true); - assert_or_panic(vec[226] == true); - assert_or_panic(vec[227] == false); - assert_or_panic(vec[228] == false); - assert_or_panic(vec[229] == false); - assert_or_panic(vec[230] == false); - assert_or_panic(vec[231] == false); - assert_or_panic(vec[232] == true); - assert_or_panic(vec[233] == true); - assert_or_panic(vec[234] == false); - assert_or_panic(vec[235] == false); - assert_or_panic(vec[236] == false); - assert_or_panic(vec[237] == true); - assert_or_panic(vec[238] == true); - assert_or_panic(vec[239] == false); - assert_or_panic(vec[240] == true); - assert_or_panic(vec[241] == true); - assert_or_panic(vec[242] == true); - assert_or_panic(vec[243] == false); - assert_or_panic(vec[244] == true); - assert_or_panic(vec[245] == true); - assert_or_panic(vec[246] == false); - assert_or_panic(vec[247] == true); - assert_or_panic(vec[248] == false); - assert_or_panic(vec[249] == false); - assert_or_panic(vec[250] == true); - assert_or_panic(vec[251] == true); - assert_or_panic(vec[252] == false); - assert_or_panic(vec[253] == true); - assert_or_panic(vec[254] == false); - assert_or_panic(vec[255] == true); - } - { - zig_vector_512_bool((Vector512Bool){ - false, - true, - true, - false, - true, - false, - true, - false, - false, - false, - false, - false, - true, - false, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - true, - false, - false, - true, - false, - true, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - false, - true, - true, - true, - false, - false, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - false, - false, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - false, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - false, - false, - true, - false, - true, - true, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - false, - false, - true, - true, - true, - false, - false, - true, - false, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - false, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - true, - false, - false, - false, - false, - true, - false, - true, - true, - false, - false, - true, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - true, - false, - true, - true, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - true, - true, - false, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - true, - true, - false, - true, - false, - false, - false, - true, - false, - false, - true, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - true, - true, - false, - false, - false, - false, - true, - false, - true, - false, - false, - false, - false, - true, - false, - false, - true, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - false, - false, - true, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - false, - true, - false, - false, - false, - true, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - true, - }); - - Vector512Bool vec = zig_ret_vector_512_bool(); - assert_or_panic(vec[0] == true); - assert_or_panic(vec[1] == true); - assert_or_panic(vec[2] == true); - assert_or_panic(vec[3] == true); - assert_or_panic(vec[4] == false); - assert_or_panic(vec[5] == true); - assert_or_panic(vec[6] == false); - assert_or_panic(vec[7] == true); - assert_or_panic(vec[8] == true); - assert_or_panic(vec[9] == true); - assert_or_panic(vec[10] == false); - assert_or_panic(vec[11] == true); - assert_or_panic(vec[12] == false); - assert_or_panic(vec[13] == false); - assert_or_panic(vec[14] == false); - assert_or_panic(vec[15] == true); - assert_or_panic(vec[16] == true); - assert_or_panic(vec[17] == false); - assert_or_panic(vec[18] == false); - assert_or_panic(vec[19] == false); - assert_or_panic(vec[20] == true); - assert_or_panic(vec[21] == true); - assert_or_panic(vec[22] == false); - assert_or_panic(vec[23] == false); - assert_or_panic(vec[24] == false); - assert_or_panic(vec[25] == false); - assert_or_panic(vec[26] == true); - assert_or_panic(vec[27] == false); - assert_or_panic(vec[28] == false); - assert_or_panic(vec[29] == false); - assert_or_panic(vec[30] == true); - assert_or_panic(vec[31] == true); - assert_or_panic(vec[32] == true); - assert_or_panic(vec[33] == true); - assert_or_panic(vec[34] == false); - assert_or_panic(vec[35] == false); - assert_or_panic(vec[36] == false); - assert_or_panic(vec[37] == true); - assert_or_panic(vec[38] == true); - assert_or_panic(vec[39] == true); - assert_or_panic(vec[40] == false); - assert_or_panic(vec[41] == false); - assert_or_panic(vec[42] == true); - assert_or_panic(vec[43] == false); - assert_or_panic(vec[44] == false); - assert_or_panic(vec[45] == true); - assert_or_panic(vec[46] == false); - assert_or_panic(vec[47] == false); - assert_or_panic(vec[48] == true); - assert_or_panic(vec[49] == true); - assert_or_panic(vec[50] == true); - assert_or_panic(vec[51] == true); - assert_or_panic(vec[52] == false); - assert_or_panic(vec[53] == false); - assert_or_panic(vec[54] == false); - assert_or_panic(vec[55] == true); - assert_or_panic(vec[56] == false); - assert_or_panic(vec[57] == true); - assert_or_panic(vec[58] == false); - assert_or_panic(vec[59] == true); - assert_or_panic(vec[60] == true); - assert_or_panic(vec[61] == false); - assert_or_panic(vec[62] == false); - assert_or_panic(vec[63] == true); - assert_or_panic(vec[64] == true); - assert_or_panic(vec[65] == false); - assert_or_panic(vec[66] == true); - assert_or_panic(vec[67] == false); - assert_or_panic(vec[68] == false); - assert_or_panic(vec[69] == false); - assert_or_panic(vec[70] == true); - assert_or_panic(vec[71] == true); - assert_or_panic(vec[72] == true); - assert_or_panic(vec[73] == true); - assert_or_panic(vec[74] == true); - assert_or_panic(vec[75] == false); - assert_or_panic(vec[76] == true); - assert_or_panic(vec[77] == false); - assert_or_panic(vec[78] == true); - assert_or_panic(vec[79] == true); - assert_or_panic(vec[80] == true); - assert_or_panic(vec[81] == true); - assert_or_panic(vec[82] == true); - assert_or_panic(vec[83] == false); - assert_or_panic(vec[84] == true); - assert_or_panic(vec[85] == true); - assert_or_panic(vec[86] == false); - assert_or_panic(vec[87] == true); - assert_or_panic(vec[88] == false); - assert_or_panic(vec[89] == false); - assert_or_panic(vec[90] == true); - assert_or_panic(vec[91] == false); - assert_or_panic(vec[92] == true); - assert_or_panic(vec[93] == false); - assert_or_panic(vec[94] == false); - assert_or_panic(vec[95] == false); - assert_or_panic(vec[96] == true); - assert_or_panic(vec[97] == true); - assert_or_panic(vec[98] == false); - assert_or_panic(vec[99] == true); - assert_or_panic(vec[100] == true); - assert_or_panic(vec[101] == false); - assert_or_panic(vec[102] == true); - assert_or_panic(vec[103] == false); - assert_or_panic(vec[104] == true); - assert_or_panic(vec[105] == false); - assert_or_panic(vec[106] == true); - assert_or_panic(vec[107] == false); - assert_or_panic(vec[108] == false); - assert_or_panic(vec[109] == true); - assert_or_panic(vec[110] == false); - assert_or_panic(vec[111] == false); - assert_or_panic(vec[112] == true); - assert_or_panic(vec[113] == false); - assert_or_panic(vec[114] == true); - assert_or_panic(vec[115] == false); - assert_or_panic(vec[116] == true); - assert_or_panic(vec[117] == false); - assert_or_panic(vec[118] == false); - assert_or_panic(vec[119] == true); - assert_or_panic(vec[120] == true); - assert_or_panic(vec[121] == true); - assert_or_panic(vec[122] == false); - assert_or_panic(vec[123] == true); - assert_or_panic(vec[124] == false); - assert_or_panic(vec[125] == false); - assert_or_panic(vec[126] == true); - assert_or_panic(vec[127] == true); - assert_or_panic(vec[128] == false); - assert_or_panic(vec[129] == true); - assert_or_panic(vec[130] == true); - assert_or_panic(vec[131] == false); - assert_or_panic(vec[132] == true); - assert_or_panic(vec[133] == true); - assert_or_panic(vec[134] == false); - assert_or_panic(vec[135] == true); - assert_or_panic(vec[136] == true); - assert_or_panic(vec[137] == false); - assert_or_panic(vec[138] == false); - assert_or_panic(vec[139] == false); - assert_or_panic(vec[140] == true); - assert_or_panic(vec[141] == false); - assert_or_panic(vec[142] == true); - assert_or_panic(vec[143] == false); - assert_or_panic(vec[144] == false); - assert_or_panic(vec[145] == false); - assert_or_panic(vec[146] == true); - assert_or_panic(vec[147] == false); - assert_or_panic(vec[148] == true); - assert_or_panic(vec[149] == false); - assert_or_panic(vec[150] == false); - assert_or_panic(vec[151] == true); - assert_or_panic(vec[152] == false); - assert_or_panic(vec[153] == true); - assert_or_panic(vec[154] == true); - assert_or_panic(vec[155] == false); - assert_or_panic(vec[156] == true); - assert_or_panic(vec[157] == true); - assert_or_panic(vec[158] == false); - assert_or_panic(vec[159] == true); - assert_or_panic(vec[160] == true); - assert_or_panic(vec[161] == false); - assert_or_panic(vec[162] == false); - assert_or_panic(vec[163] == false); - assert_or_panic(vec[164] == true); - assert_or_panic(vec[165] == false); - assert_or_panic(vec[166] == true); - assert_or_panic(vec[167] == true); - assert_or_panic(vec[168] == true); - assert_or_panic(vec[169] == true); - assert_or_panic(vec[170] == false); - assert_or_panic(vec[171] == true); - assert_or_panic(vec[172] == false); - assert_or_panic(vec[173] == false); - assert_or_panic(vec[174] == true); - assert_or_panic(vec[175] == true); - assert_or_panic(vec[176] == true); - assert_or_panic(vec[177] == false); - assert_or_panic(vec[178] == false); - assert_or_panic(vec[179] == false); - assert_or_panic(vec[180] == true); - assert_or_panic(vec[181] == false); - assert_or_panic(vec[182] == false); - assert_or_panic(vec[183] == true); - assert_or_panic(vec[184] == true); - assert_or_panic(vec[185] == false); - assert_or_panic(vec[186] == true); - assert_or_panic(vec[187] == false); - assert_or_panic(vec[188] == true); - assert_or_panic(vec[189] == true); - assert_or_panic(vec[190] == true); - assert_or_panic(vec[191] == true); - assert_or_panic(vec[192] == true); - assert_or_panic(vec[193] == true); - assert_or_panic(vec[194] == true); - assert_or_panic(vec[195] == false); - assert_or_panic(vec[196] == false); - assert_or_panic(vec[197] == false); - assert_or_panic(vec[198] == false); - assert_or_panic(vec[199] == false); - assert_or_panic(vec[200] == true); - assert_or_panic(vec[201] == false); - assert_or_panic(vec[202] == true); - assert_or_panic(vec[203] == false); - assert_or_panic(vec[204] == true); - assert_or_panic(vec[205] == true); - assert_or_panic(vec[206] == false); - assert_or_panic(vec[207] == false); - assert_or_panic(vec[208] == false); - assert_or_panic(vec[209] == true); - assert_or_panic(vec[210] == true); - assert_or_panic(vec[211] == true); - assert_or_panic(vec[212] == false); - assert_or_panic(vec[213] == false); - assert_or_panic(vec[214] == true); - assert_or_panic(vec[215] == true); - assert_or_panic(vec[216] == true); - assert_or_panic(vec[217] == false); - assert_or_panic(vec[218] == false); - assert_or_panic(vec[219] == true); - assert_or_panic(vec[220] == false); - assert_or_panic(vec[221] == true); - assert_or_panic(vec[222] == true); - assert_or_panic(vec[223] == false); - assert_or_panic(vec[224] == true); - assert_or_panic(vec[225] == false); - assert_or_panic(vec[226] == false); - assert_or_panic(vec[227] == true); - assert_or_panic(vec[228] == false); - assert_or_panic(vec[229] == false); - assert_or_panic(vec[230] == true); - assert_or_panic(vec[231] == true); - assert_or_panic(vec[232] == false); - assert_or_panic(vec[233] == true); - assert_or_panic(vec[234] == true); - assert_or_panic(vec[235] == true); - assert_or_panic(vec[236] == true); - assert_or_panic(vec[237] == true); - assert_or_panic(vec[238] == false); - assert_or_panic(vec[239] == true); - assert_or_panic(vec[240] == false); - assert_or_panic(vec[241] == false); - assert_or_panic(vec[242] == true); - assert_or_panic(vec[243] == false); - assert_or_panic(vec[244] == true); - assert_or_panic(vec[245] == false); - assert_or_panic(vec[246] == true); - assert_or_panic(vec[247] == false); - assert_or_panic(vec[248] == true); - assert_or_panic(vec[249] == true); - assert_or_panic(vec[250] == true); - assert_or_panic(vec[251] == true); - assert_or_panic(vec[252] == true); - assert_or_panic(vec[253] == false); - assert_or_panic(vec[254] == false); - assert_or_panic(vec[255] == false); - assert_or_panic(vec[256] == false); - assert_or_panic(vec[257] == false); - assert_or_panic(vec[258] == false); - assert_or_panic(vec[259] == true); - assert_or_panic(vec[260] == true); - assert_or_panic(vec[261] == true); - assert_or_panic(vec[262] == true); - assert_or_panic(vec[263] == false); - assert_or_panic(vec[264] == false); - assert_or_panic(vec[265] == false); - assert_or_panic(vec[266] == true); - assert_or_panic(vec[267] == false); - assert_or_panic(vec[268] == true); - assert_or_panic(vec[269] == false); - assert_or_panic(vec[270] == true); - assert_or_panic(vec[271] == true); - assert_or_panic(vec[272] == true); - assert_or_panic(vec[273] == true); - assert_or_panic(vec[274] == true); - assert_or_panic(vec[275] == true); - assert_or_panic(vec[276] == false); - assert_or_panic(vec[277] == false); - assert_or_panic(vec[278] == true); - assert_or_panic(vec[279] == true); - assert_or_panic(vec[280] == false); - assert_or_panic(vec[281] == false); - assert_or_panic(vec[282] == false); - assert_or_panic(vec[283] == false); - assert_or_panic(vec[284] == true); - assert_or_panic(vec[285] == true); - assert_or_panic(vec[286] == true); - assert_or_panic(vec[287] == false); - assert_or_panic(vec[288] == false); - assert_or_panic(vec[289] == false); - assert_or_panic(vec[290] == true); - assert_or_panic(vec[291] == false); - assert_or_panic(vec[292] == true); - assert_or_panic(vec[293] == true); - assert_or_panic(vec[294] == false); - assert_or_panic(vec[295] == true); - assert_or_panic(vec[296] == true); - assert_or_panic(vec[297] == true); - assert_or_panic(vec[298] == false); - assert_or_panic(vec[299] == true); - assert_or_panic(vec[300] == true); - assert_or_panic(vec[301] == false); - assert_or_panic(vec[302] == false); - assert_or_panic(vec[303] == true); - assert_or_panic(vec[304] == false); - assert_or_panic(vec[305] == false); - assert_or_panic(vec[306] == true); - assert_or_panic(vec[307] == true); - assert_or_panic(vec[308] == true); - assert_or_panic(vec[309] == true); - assert_or_panic(vec[310] == false); - assert_or_panic(vec[311] == false); - assert_or_panic(vec[312] == false); - assert_or_panic(vec[313] == false); - assert_or_panic(vec[314] == false); - assert_or_panic(vec[315] == true); - assert_or_panic(vec[316] == false); - assert_or_panic(vec[317] == false); - assert_or_panic(vec[318] == true); - assert_or_panic(vec[319] == false); - assert_or_panic(vec[320] == false); - assert_or_panic(vec[321] == true); - assert_or_panic(vec[322] == true); - assert_or_panic(vec[323] == true); - assert_or_panic(vec[324] == true); - assert_or_panic(vec[325] == false); - assert_or_panic(vec[326] == false); - assert_or_panic(vec[327] == false); - assert_or_panic(vec[328] == true); - assert_or_panic(vec[329] == true); - assert_or_panic(vec[330] == false); - assert_or_panic(vec[331] == true); - assert_or_panic(vec[332] == true); - assert_or_panic(vec[333] == false); - assert_or_panic(vec[334] == false); - assert_or_panic(vec[335] == true); - assert_or_panic(vec[336] == true); - assert_or_panic(vec[337] == false); - assert_or_panic(vec[338] == true); - assert_or_panic(vec[339] == true); - assert_or_panic(vec[340] == true); - assert_or_panic(vec[341] == false); - assert_or_panic(vec[342] == false); - assert_or_panic(vec[343] == false); - assert_or_panic(vec[344] == true); - assert_or_panic(vec[345] == true); - assert_or_panic(vec[346] == false); - assert_or_panic(vec[347] == true); - assert_or_panic(vec[348] == false); - assert_or_panic(vec[349] == true); - assert_or_panic(vec[350] == false); - assert_or_panic(vec[351] == false); - assert_or_panic(vec[352] == true); - assert_or_panic(vec[353] == false); - assert_or_panic(vec[354] == true); - assert_or_panic(vec[355] == false); - assert_or_panic(vec[356] == false); - assert_or_panic(vec[357] == false); - assert_or_panic(vec[358] == false); - assert_or_panic(vec[359] == false); - assert_or_panic(vec[360] == true); - assert_or_panic(vec[361] == true); - assert_or_panic(vec[362] == false); - assert_or_panic(vec[363] == false); - assert_or_panic(vec[364] == false); - assert_or_panic(vec[365] == false); - assert_or_panic(vec[366] == true); - assert_or_panic(vec[367] == false); - assert_or_panic(vec[368] == true); - assert_or_panic(vec[369] == false); - assert_or_panic(vec[370] == true); - assert_or_panic(vec[371] == true); - assert_or_panic(vec[372] == false); - assert_or_panic(vec[373] == true); - assert_or_panic(vec[374] == true); - assert_or_panic(vec[375] == true); - assert_or_panic(vec[376] == true); - assert_or_panic(vec[377] == true); - assert_or_panic(vec[378] == false); - assert_or_panic(vec[379] == true); - assert_or_panic(vec[380] == false); - assert_or_panic(vec[381] == true); - assert_or_panic(vec[382] == true); - assert_or_panic(vec[383] == true); - assert_or_panic(vec[384] == true); - assert_or_panic(vec[385] == true); - assert_or_panic(vec[386] == false); - assert_or_panic(vec[387] == true); - assert_or_panic(vec[388] == true); - assert_or_panic(vec[389] == false); - assert_or_panic(vec[390] == true); - assert_or_panic(vec[391] == false); - assert_or_panic(vec[392] == true); - assert_or_panic(vec[393] == false); - assert_or_panic(vec[394] == true); - assert_or_panic(vec[395] == false); - assert_or_panic(vec[396] == true); - assert_or_panic(vec[397] == false); - assert_or_panic(vec[398] == false); - assert_or_panic(vec[399] == true); - assert_or_panic(vec[400] == true); - assert_or_panic(vec[401] == true); - assert_or_panic(vec[402] == true); - assert_or_panic(vec[403] == false); - assert_or_panic(vec[404] == false); - assert_or_panic(vec[405] == true); - assert_or_panic(vec[406] == false); - assert_or_panic(vec[407] == false); - assert_or_panic(vec[408] == false); - assert_or_panic(vec[409] == true); - assert_or_panic(vec[410] == false); - assert_or_panic(vec[411] == true); - assert_or_panic(vec[412] == true); - assert_or_panic(vec[413] == false); - assert_or_panic(vec[414] == true); - assert_or_panic(vec[415] == true); - assert_or_panic(vec[416] == false); - assert_or_panic(vec[417] == true); - assert_or_panic(vec[418] == true); - assert_or_panic(vec[419] == false); - assert_or_panic(vec[420] == false); - assert_or_panic(vec[421] == true); - assert_or_panic(vec[422] == false); - assert_or_panic(vec[423] == false); - assert_or_panic(vec[424] == true); - assert_or_panic(vec[425] == false); - assert_or_panic(vec[426] == true); - assert_or_panic(vec[427] == false); - assert_or_panic(vec[428] == false); - assert_or_panic(vec[429] == true); - assert_or_panic(vec[430] == false); - assert_or_panic(vec[431] == true); - assert_or_panic(vec[432] == true); - assert_or_panic(vec[433] == false); - assert_or_panic(vec[434] == true); - assert_or_panic(vec[435] == false); - assert_or_panic(vec[436] == true); - assert_or_panic(vec[437] == false); - assert_or_panic(vec[438] == true); - assert_or_panic(vec[439] == false); - assert_or_panic(vec[440] == false); - assert_or_panic(vec[441] == true); - assert_or_panic(vec[442] == true); - assert_or_panic(vec[443] == false); - assert_or_panic(vec[444] == true); - assert_or_panic(vec[445] == true); - assert_or_panic(vec[446] == false); - assert_or_panic(vec[447] == true); - assert_or_panic(vec[448] == true); - assert_or_panic(vec[449] == false); - assert_or_panic(vec[450] == false); - assert_or_panic(vec[451] == false); - assert_or_panic(vec[452] == false); - assert_or_panic(vec[453] == false); - assert_or_panic(vec[454] == true); - assert_or_panic(vec[455] == false); - assert_or_panic(vec[456] == false); - assert_or_panic(vec[457] == true); - assert_or_panic(vec[458] == false); - assert_or_panic(vec[459] == true); - assert_or_panic(vec[460] == false); - assert_or_panic(vec[461] == false); - assert_or_panic(vec[462] == false); - assert_or_panic(vec[463] == true); - assert_or_panic(vec[464] == false); - assert_or_panic(vec[465] == true); - assert_or_panic(vec[466] == false); - assert_or_panic(vec[467] == false); - assert_or_panic(vec[468] == false); - assert_or_panic(vec[469] == false); - assert_or_panic(vec[470] == true); - assert_or_panic(vec[471] == true); - assert_or_panic(vec[472] == false); - assert_or_panic(vec[473] == true); - assert_or_panic(vec[474] == true); - assert_or_panic(vec[475] == false); - assert_or_panic(vec[476] == false); - assert_or_panic(vec[477] == true); - assert_or_panic(vec[478] == true); - assert_or_panic(vec[479] == true); - assert_or_panic(vec[480] == false); - assert_or_panic(vec[481] == false); - assert_or_panic(vec[482] == true); - assert_or_panic(vec[483] == false); - assert_or_panic(vec[484] == false); - assert_or_panic(vec[485] == false); - assert_or_panic(vec[486] == true); - assert_or_panic(vec[487] == true); - assert_or_panic(vec[488] == false); - assert_or_panic(vec[489] == false); - assert_or_panic(vec[490] == false); - assert_or_panic(vec[491] == false); - assert_or_panic(vec[492] == false); - assert_or_panic(vec[493] == true); - assert_or_panic(vec[494] == true); - assert_or_panic(vec[495] == true); - assert_or_panic(vec[496] == true); - assert_or_panic(vec[497] == false); - assert_or_panic(vec[498] == false); - assert_or_panic(vec[499] == false); - assert_or_panic(vec[500] == true); - assert_or_panic(vec[501] == false); - assert_or_panic(vec[502] == true); - assert_or_panic(vec[503] == true); - assert_or_panic(vec[504] == true); - assert_or_panic(vec[505] == true); - assert_or_panic(vec[506] == false); - assert_or_panic(vec[507] == false); - assert_or_panic(vec[508] == true); - assert_or_panic(vec[509] == true); - assert_or_panic(vec[510] == false); - assert_or_panic(vec[511] == false); - } -#endif } void c_u8(uint8_t x) { @@ -5386,51 +15654,6 @@ void c_big_union(union BigUnion x) { assert_or_panic(x.a.d == 4); } -void c_small_struct_ints(struct SmallStructInts x) { - assert_or_panic(x.a == 1); - assert_or_panic(x.b == 2); - assert_or_panic(x.c == 3); - assert_or_panic(x.d == 4); - - struct SmallStructInts y = zig_ret_small_struct_ints(); - - assert_or_panic(y.a == 1); - assert_or_panic(y.b == 2); - assert_or_panic(y.c == 3); - assert_or_panic(y.d == 4); -} - -struct SmallStructInts c_ret_small_struct_ints() { - struct SmallStructInts s = { - .a = 1, - .b = 2, - .c = 3, - .d = 4, - }; - return s; -} - -void c_med_struct_ints(struct MedStructInts s) { - assert_or_panic(s.x == 1); - assert_or_panic(s.y == 2); - assert_or_panic(s.z == 3); - - struct MedStructInts s2 = zig_ret_med_struct_ints(); - - assert_or_panic(s2.x == 1); - assert_or_panic(s2.y == 2); - assert_or_panic(s2.z == 3); -} - -struct MedStructInts c_ret_med_struct_ints() { - struct MedStructInts s = { - .x = 1, - .y = 2, - .z = 3, - }; - return s; -} - void c_med_struct_mixed(struct MedStructMixed x) { assert_or_panic(x.a == 1234); assert_or_panic(x.b == 100.0f); @@ -5443,7 +15666,7 @@ void c_med_struct_mixed(struct MedStructMixed x) { assert_or_panic(y.c == 1337.0f); } -struct MedStructMixed c_ret_med_struct_mixed() { +struct MedStructMixed c_ret_med_struct_mixed(void) { struct MedStructMixed s = { .a = 1234, .b = 100.0, @@ -5469,7 +15692,7 @@ void c_split_struct_mixed(struct SplitStructMixed x) { assert_or_panic(y.c == 1337.0f); } -uint8_t c_ret_small_packed_struct() { +uint8_t c_ret_small_packed_struct(void) { uint8_t s = 0; s |= 0 << 0; s |= 1 << 2; @@ -5486,7 +15709,7 @@ void c_small_packed_struct(uint8_t x) { } #ifndef ZIG_NO_I128 -__int128 c_ret_big_packed_struct() { +__int128 c_ret_big_packed_struct(void) { __int128 s = 0; s |= 1 << 0; s |= (__int128)2 << 64; @@ -5499,7 +15722,7 @@ void c_big_packed_struct(__int128 x) { } #endif -struct SplitStructMixed c_ret_split_struct_mixed() { +struct SplitStructMixed c_ret_split_struct_mixed(void) { struct SplitStructMixed s = { .a = 1234, .b = 100, @@ -5518,74 +15741,31 @@ struct BigStruct c_big_struct_both(struct BigStruct x) { return y; } -void c_small_struct_floats(Vector3 vec) { - assert_or_panic(vec.x == 3.0); - assert_or_panic(vec.y == 6.0); - assert_or_panic(vec.z == 12.0); -} - -void c_small_struct_floats_extra(Vector3 vec, const char *str) { - assert_or_panic(vec.x == 3.0); - assert_or_panic(vec.y == 6.0); - assert_or_panic(vec.z == 12.0); - assert_or_panic(!strcmp(str, "hello")); -} - -void c_big_struct_floats(Vector5 vec) { - assert_or_panic(vec.x == 76.0); - assert_or_panic(vec.y == -1.0); - assert_or_panic(vec.z == -12.0); - assert_or_panic(vec.w == 69); - assert_or_panic(vec.q == 55); -} - -void c_multiple_struct_ints(Rect x, Rect y) { - assert_or_panic(x.left == 1); - assert_or_panic(x.right == 21); - assert_or_panic(x.top == 16); - assert_or_panic(x.bottom == 4); - assert_or_panic(y.left == 178); - assert_or_panic(y.right == 189); - assert_or_panic(y.top == 21); - assert_or_panic(y.bottom == 15); -} - -void c_multiple_struct_floats(FloatRect x, FloatRect y) { - assert_or_panic(x.left == 1); - assert_or_panic(x.right == 21); - assert_or_panic(x.top == 16); - assert_or_panic(x.bottom == 4); - assert_or_panic(y.left == 178); - assert_or_panic(y.right == 189); - assert_or_panic(y.top == 21); - assert_or_panic(y.bottom == 15); -} - -bool c_ret_bool() { +bool c_ret_bool(void) { return 1; } -uint8_t c_ret_u8() { +uint8_t c_ret_u8(void) { return 0xff; } -uint16_t c_ret_u16() { +uint16_t c_ret_u16(void) { return 0xffff; } -uint32_t c_ret_u32() { +uint32_t c_ret_u32(void) { return 0xffffffff; } -uint64_t c_ret_u64() { +uint64_t c_ret_u64(void) { return 0xffffffffffffffff; } -int8_t c_ret_i8() { +int8_t c_ret_i8(void) { return -1; } -int16_t c_ret_i16() { +int16_t c_ret_i16(void) { return -1; } -int32_t c_ret_i32() { +int32_t c_ret_i32(void) { return -1; } -int64_t c_ret_i64() { +int64_t c_ret_i64(void) { return -1; } @@ -5600,7 +15780,7 @@ void c_struct_with_array(StructWithArray x) { assert_or_panic(x.b == 2); } -StructWithArray c_ret_struct_with_array() { +StructWithArray c_ret_struct_with_array(void) { return (StructWithArray){4, {}, 155}; } @@ -5622,7 +15802,7 @@ void c_float_array_struct(FloatArrayStruct x) { assert_or_panic(x.size.height == 8); } -FloatArrayStruct c_ret_float_array_struct() { +FloatArrayStruct c_ret_float_array_struct(void) { FloatArrayStruct x; x.origin.x = 1; x.origin.y = 2; @@ -5898,7 +16078,6 @@ struct ByRef __attribute__((sysv_abi)) c_explict_sys_v(struct ByRef in) { } #endif - struct byval_tail_callsite_attr_Point { double x; double y; diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig index a5057adacf13c87550be8ee885a00d2c5233078b..331805e878635b545e531d5ac1ad6900f8e74592 100644 --- a/test/c_abi/main.zig +++ b/test/c_abi/main.zig @@ -18,13 +18,12 @@ const have_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isArm() and const have_f128 = builtin.cpu.arch.isWasm() or (builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin() and builtin.abi != .msvc); const have_f80 = builtin.cpu.arch.isX86() and builtin.abi != .msvc; -extern fn run_c_tests() void; - export fn zig_panic() noreturn { @panic("zig_panic called from C"); } -test "C importing Zig ABI Tests" { +extern fn run_c_tests() void; +test run_c_tests { run_c_tests(); } @@ -50,7 +49,7 @@ export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void { expect(e == 90) catch @panic("test failure: zig_five_integers 90"); } -test "C ABI integers" { +test "integers" { if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; c_u8(0xff); @@ -120,13 +119,13 @@ export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void { expect(e == 5.0) catch @panic("test failure: zig_five_floats 5.0"); } -test "C ABI floats" { +test "floats" { c_f32(12.34); c_f64(56.78); c_five_floats(1.0, 2.0, 3.0, 4.0, 5.0); } -test "C ABI long double" { +test "long double" { if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; c_long_double(12.34); @@ -145,7 +144,7 @@ export fn zig_longdouble(x: c_longdouble) void { extern fn c_ptr(*anyopaque) void; -test "C ABI pointer" { +test "pointer" { c_ptr(@as(*anyopaque, @ptrFromInt(0xdeadbeef))); } @@ -155,7 +154,7 @@ export fn zig_ptr(x: *anyopaque) void { extern fn c_bool(bool) void; -test "C ABI bool" { +test "bool" { c_bool(true); } @@ -190,7 +189,7 @@ const complex_abi_compatible = builtin.cpu.arch != .x86 and !builtin.cpu.arch.is builtin.cpu.arch != .s390x and !(builtin.cpu.arch.isLoongArch() and builtin.abi.float() == .soft); -test "C ABI complex float" { +test "complex float" { if (!complex_abi_compatible) return error.SkipZigTest; const a = ComplexFloat{ .real = 1.25, .imag = 2.6 }; @@ -201,7 +200,7 @@ test "C ABI complex float" { try expect(z.imag == 13.5); } -test "C ABI complex float by component" { +test "complex float by component" { if (!complex_abi_compatible) return error.SkipZigTest; const a = ComplexFloat{ .real = 1.25, .imag = 2.6 }; @@ -212,7 +211,7 @@ test "C ABI complex float by component" { try expect(z2.imag == 13.5); } -test "C ABI complex double" { +test "complex double" { if (!complex_abi_compatible) return error.SkipZigTest; const a = ComplexDouble{ .real = 1.25, .imag = 2.6 }; @@ -223,7 +222,7 @@ test "C ABI complex double" { try expect(z.imag == 13.5); } -test "C ABI complex double by component" { +test "complex double by component" { if (!complex_abi_compatible) return error.SkipZigTest; const a = ComplexDouble{ .real = 1.25, .imag = 2.6 }; @@ -270,3307 +269,109 @@ export fn zig_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble return .{ .real = 1.5, .imag = 13.5 }; } -const Struct_u8 = extern struct { - a: u8, -}; - -export fn zig_ret_struct_u8() Struct_u8 { - return .{ .a = 1 }; -} - -export fn zig_struct_u8(s: Struct_u8, i: usize) void { - expect(s.a == 2) catch @panic("test failure"); - expect(i == 3) catch @panic("test failure"); -} - -extern fn c_ret_struct_u8() Struct_u8; - -extern fn c_struct_u8(Struct_u8, usize) void; - -test "C ABI struct u8" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_u8(); - try expect(s.a == 4); - c_struct_u8(.{ .a = 5 }, 6); -} - -const Struct_u16 = extern struct { - a: u16, -}; - -export fn zig_ret_struct_u16() Struct_u16 { - return .{ .a = 7 }; -} - -export fn zig_struct_u16(s: Struct_u16, i: usize) void { - expect(s.a == 8) catch @panic("test failure"); - expect(i == 9) catch @panic("test failure"); -} - -extern fn c_ret_struct_u16() Struct_u16; - -extern fn c_struct_u16(Struct_u16, usize) void; - -test "C ABI struct u16" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_u16(); - try expect(s.a == 10); - c_struct_u16(.{ .a = 11 }, 12); -} - -const Struct_u32 = extern struct { - a: u32, -}; - -export fn zig_ret_struct_u32() Struct_u32 { - return .{ .a = 13 }; -} - -export fn zig_struct_u32(s: Struct_u32, i: usize) void { - expect(s.a == 14) catch @panic("test failure"); - expect(i == 15) catch @panic("test failure"); -} - -extern fn c_ret_struct_u32() Struct_u32; - -extern fn c_struct_u32(Struct_u32, usize) void; - -test "C ABI struct u32" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_u32(); - try expect(s.a == 16); - c_struct_u32(.{ .a = 17 }, 18); -} - -const Struct_u64 = extern struct { - a: u64, -}; - -export fn zig_ret_struct_u64() Struct_u64 { - return .{ .a = 19 }; -} - -export fn zig_struct_u64(s: Struct_u64, i: usize) void { - expect(s.a == 20) catch @panic("test failure"); - expect(i == 21) catch @panic("test failure"); -} - -extern fn c_ret_struct_u64() Struct_u64; - -extern fn c_struct_u64(Struct_u64, usize) void; - -test "C ABI struct u64" { - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .riscv32) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_u64(); - try expect(s.a == 22); - c_struct_u64(.{ .a = 23 }, 24); -} - -const Struct_u64_u64 = extern struct { - a: u64, - b: u64, -}; - -export fn zig_ret_struct_u64_u64() Struct_u64_u64 { - return .{ .a = 1, .b = 2 }; -} - -export fn zig_struct_u64_u64_0(s: Struct_u64_u64, i: usize) void { - expect(s.a == 3) catch @panic("test failure"); - expect(s.b == 4) catch @panic("test failure"); - expect(i == 1) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_1(_: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 5) catch @panic("test failure"); - expect(s.b == 6) catch @panic("test failure"); - expect(i == 2) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_2(_: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 7) catch @panic("test failure"); - expect(s.b == 8) catch @panic("test failure"); - expect(i == 3) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_3(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 9) catch @panic("test failure"); - expect(s.b == 10) catch @panic("test failure"); - expect(i == 4) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_4(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 11) catch @panic("test failure"); - expect(s.b == 12) catch @panic("test failure"); - expect(i == 5) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_5(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 13) catch @panic("test failure"); - expect(s.b == 14) catch @panic("test failure"); - expect(i == 6) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_6(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 15) catch @panic("test failure"); - expect(s.b == 16) catch @panic("test failure"); - expect(i == 7) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_7(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 17) catch @panic("test failure"); - expect(s.b == 18) catch @panic("test failure"); - expect(i == 8) catch @panic("test failure"); -} -export fn zig_struct_u64_u64_8(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { - expect(s.a == 19) catch @panic("test failure"); - expect(s.b == 20) catch @panic("test failure"); - expect(i == 9) catch @panic("test failure"); -} - -extern fn c_ret_struct_u64_u64() Struct_u64_u64; - -extern fn c_struct_u64_u64_0(Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_1(usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_2(usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_3(usize, usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_4(usize, usize, usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_5(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_6(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_7(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; -extern fn c_struct_u64_u64_8(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; - -test "C ABI struct u64, u64" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = c_ret_struct_u64_u64(); - try expect(s.a == 21); - try expect(s.b == 22); - c_struct_u64_u64_0(.{ .a = 23, .b = 24 }, 1); - c_struct_u64_u64_1(0, .{ .a = 25, .b = 26 }, 2); - c_struct_u64_u64_2(0, 1, .{ .a = 27, .b = 28 }, 3); - c_struct_u64_u64_3(0, 1, 2, .{ .a = 29, .b = 30 }, 4); - c_struct_u64_u64_4(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5); - c_struct_u64_u64_5(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6); - c_struct_u64_u64_6(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7); - c_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8); - c_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9); -} - -const Struct_f32 = extern struct { - a: f32, -}; - -export fn zig_ret_struct_f32() Struct_f32 { - return .{ .a = 2.5 }; -} - -export fn zig_struct_f32(s: Struct_f32) void { - expect(s.a == 2.5) catch @panic("test failure"); -} - -extern fn c_ret_struct_f32() Struct_f32; - -extern fn c_struct_f32(Struct_f32) void; - -test "C ABI struct f32" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_f32(); - try expect(s.a == 2.5); - c_struct_f32(.{ .a = 2.5 }); -} - -const Struct_f64 = extern struct { - a: f64, -}; - -export fn zig_ret_struct_f64() Struct_f64 { - return .{ .a = 2.5 }; -} - -export fn zig_struct_f64(s: Struct_f64) void { - expect(s.a == 2.5) catch @panic("test failure"); -} - -extern fn c_ret_struct_f64() Struct_f64; - -extern fn c_struct_f64(Struct_f64) void; - -test "C ABI struct f64" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; - if (builtin.cpu.arch == .riscv32) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s = c_ret_struct_f64(); - try expect(s.a == 2.5); - c_struct_f64(.{ .a = 2.5 }); -} - -const Struct_f32a8 = extern struct { - a: f32 align(8), -}; - -export fn zig_ret_struct_f32a8() Struct_f32a8 { - return .{ .a = 1.25 }; -} - -export fn zig_struct_f32a8(s: Struct_f32a8, f: f32) void { - expect(s.a == 2.75) catch @panic("test failure"); - expect(f == 3.5) catch @panic("test failure"); -} - -extern fn c_ret_struct_f32a8() Struct_f32a8; - -extern fn c_struct_f32a8(Struct_f32a8, f32) void; - -test "C ABI struct f32 align(8)" { - if (builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch == .riscv32) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - - const s = c_ret_struct_f32a8(); - try expect(s.a == 4.125); - c_struct_f32a8(.{ .a = 5.375 }, 6.5); -} - -const Struct_f32a8_f32a8 = extern struct { - a: f32 align(8), - b: f32 align(8), -}; - -export fn zig_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8 { - return .{ .a = 1.25, .b = 2.75 }; -} - -export fn zig_struct_f32a8_f32a8(s: Struct_f32a8_f32a8, f: f32) void { - expect(s.a == 3.125) catch @panic("test failure"); - expect(s.b == 4.375) catch @panic("test failure"); - expect(f == 5.5) catch @panic("test failure"); -} - -extern fn c_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8; - -extern fn c_struct_f32a8_f32a8(Struct_f32a8_f32a8, f32) void; - -test "C ABI struct f32 align(8), f32 align(8)" { - if (builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - - const s = c_ret_struct_f32a8_f32a8(); - try expect(s.a == 6.625); - try expect(s.b == 7.875); - c_struct_f32a8_f32a8(.{ .a = 8.0625, .b = 9.1875 }, 10.5); -} - -const Struct_f32f32_f32 = extern struct { - a: extern struct { b: f32, c: f32 }, - d: f32, -}; - -export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 { - return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 }; -} - -export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void { - expect(s.a.b == 1.0) catch @panic("test failure"); - expect(s.a.c == 2.0) catch @panic("test failure"); - expect(s.d == 3.0) catch @panic("test failure"); -} - -extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32; - -extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void; - -test "C ABI struct {f32, f32}, f32" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = c_ret_struct_f32f32_f32(); - try expect(s.a.b == 1.0); - try expect(s.a.c == 2.0); - try expect(s.d == 3.0); - c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 }); -} - -const Struct_f32_f32f32 = extern struct { - a: f32, - b: extern struct { c: f32, d: f32 }, -}; - -export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 { - return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } }; -} - -export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void { - expect(s.a == 1.0) catch @panic("test failure"); - expect(s.b.c == 2.0) catch @panic("test failure"); - expect(s.b.d == 3.0) catch @panic("test failure"); -} - -extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32; - -extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void; - -test "C ABI struct f32 {f32,f32}" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = c_ret_struct_f32_f32f32(); - try expect(s.a == 1.0); - try expect(s.b.c == 2.0); - try expect(s.b.d == 3.0); - c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } }); -} - -const Struct_u32_Union_u32_u32u32 = extern struct { - a: u32, - b: extern union { - c: extern struct { - d: u32, - e: u32, - }, - }, -}; - -export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 { - return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } }; -} - -export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void { - expect(s.a == 1) catch @panic("test failure"); - expect(s.b.c.d == 2) catch @panic("test failure"); - expect(s.b.c.e == 3) catch @panic("test failure"); -} - -extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32; - -extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void; - -test "C ABI struct{u32,union{u32,struct{u32,u32}}}" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = c_ret_struct_u32_union_u32_u32u32(); - try expect(s.a == 1); - try expect(s.b.c.d == 2); - try expect(s.b.c.e == 3); - c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } }); -} - -const Struct_i32_i32 = extern struct { - a: i32, - b: i32, -}; -extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32; -extern fn c_struct_i32_i32(Struct_i32_i32) void; - -test "C ABI struct i32 i32" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch == .riscv32) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - - const s: Struct_i32_i32 = .{ - .a = 1, - .b = 2, - }; - const mut_res = c_mut_struct_i32_i32(s); - try expect(s.a == 1); - try expect(s.b == 2); - try expect(mut_res.a == 101); - try expect(mut_res.b == 252); - c_struct_i32_i32(s); -} - -export fn zig_struct_i32_i32(s: Struct_i32_i32) void { - expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1"); - expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2"); -} - -const BigStruct = extern struct { - a: u64, - b: u64, - c: u64, - d: u64, - e: u8, -}; -extern fn c_big_struct(BigStruct) void; - -test "C ABI big struct" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = BigStruct{ - .a = 1, - .b = 2, - .c = 3, - .d = 4, - .e = 5, - }; - c_big_struct(s); -} - -export fn zig_big_struct(x: BigStruct) void { - expect(x.a == 1) catch @panic("test failure: zig_big_struct 1"); - expect(x.b == 2) catch @panic("test failure: zig_big_struct 2"); - expect(x.c == 3) catch @panic("test failure: zig_big_struct 3"); - expect(x.d == 4) catch @panic("test failure: zig_big_struct 4"); - expect(x.e == 5) catch @panic("test failure: zig_big_struct 5"); -} - -const BigUnion = extern union { - a: BigStruct, -}; -extern fn c_big_union(BigUnion) void; - -test "C ABI big union" { - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const x = BigUnion{ - .a = BigStruct{ - .a = 1, - .b = 2, - .c = 3, - .d = 4, - .e = 5, - }, - }; - c_big_union(x); -} - -export fn zig_big_union(x: BigUnion) void { - expect(x.a.a == 1) catch @panic("test failure: zig_big_union a"); - expect(x.a.b == 2) catch @panic("test failure: zig_big_union b"); - expect(x.a.c == 3) catch @panic("test failure: zig_big_union c"); - expect(x.a.d == 4) catch @panic("test failure: zig_big_union d"); - expect(x.a.e == 5) catch @panic("test failure: zig_big_union e"); -} - -const MedStructMixed = extern struct { - a: u32, - b: f32, - c: f32, - d: u32 = 0, -}; -extern fn c_med_struct_mixed(MedStructMixed) void; -extern fn c_ret_med_struct_mixed() MedStructMixed; - -test "C ABI medium struct of ints and floats" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = MedStructMixed{ - .a = 1234, - .b = 100.0, - .c = 1337.0, - }; - c_med_struct_mixed(s); - const s2 = c_ret_med_struct_mixed(); - try expect(s2.a == 1234); - try expect(s2.b == 100.0); - try expect(s2.c == 1337.0); -} - -export fn zig_med_struct_mixed(x: MedStructMixed) void { - expect(x.a == 1234) catch @panic("test failure"); - expect(x.b == 100.0) catch @panic("test failure"); - expect(x.c == 1337.0) catch @panic("test failure"); -} - -const SmallStructInts = extern struct { - a: u8, - b: u8, - c: u8, - d: u8, -}; -extern fn c_small_struct_ints(SmallStructInts) void; -extern fn c_ret_small_struct_ints() SmallStructInts; - -test "C ABI small struct of ints" { - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = SmallStructInts{ - .a = 1, - .b = 2, - .c = 3, - .d = 4, - }; - c_small_struct_ints(s); - const s2 = c_ret_small_struct_ints(); - try expect(s2.a == 1); - try expect(s2.b == 2); - try expect(s2.c == 3); - try expect(s2.d == 4); -} - -export fn zig_small_struct_ints(x: SmallStructInts) void { - expect(x.a == 1) catch @panic("test failure"); - expect(x.b == 2) catch @panic("test failure"); - expect(x.c == 3) catch @panic("test failure"); - expect(x.d == 4) catch @panic("test failure"); -} - -const MedStructInts = extern struct { - x: i32, - y: i32, - z: i32, -}; -extern fn c_med_struct_ints(MedStructInts) void; -extern fn c_ret_med_struct_ints() MedStructInts; - -test "C ABI medium struct of ints" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = MedStructInts{ - .x = 1, - .y = 2, - .z = 3, - }; - c_med_struct_ints(s); - const s2 = c_ret_med_struct_ints(); - try expect(s2.x == 1); - try expect(s2.y == 2); - try expect(s2.z == 3); -} - -export fn zig_med_struct_ints(s: MedStructInts) void { - expect(s.x == 1) catch @panic("test failure"); - expect(s.y == 2) catch @panic("test failure"); - expect(s.z == 3) catch @panic("test failure"); -} - -const SmallPackedStruct = packed struct(u8) { - a: u2, - b: u2, - c: u2, - d: u2, -}; -extern fn c_small_packed_struct(SmallPackedStruct) void; -extern fn c_ret_small_packed_struct() SmallPackedStruct; - -export fn zig_small_packed_struct(x: SmallPackedStruct) void { - expect(x.a == 0) catch @panic("test failure"); - expect(x.b == 1) catch @panic("test failure"); - expect(x.c == 2) catch @panic("test failure"); - expect(x.d == 3) catch @panic("test failure"); -} - -test "C ABI small packed struct" { - const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 }; - c_small_packed_struct(s); - const s2 = c_ret_small_packed_struct(); - try expect(s2.a == 0); - try expect(s2.b == 1); - try expect(s2.c == 2); - try expect(s2.d == 3); -} - -const BigPackedStruct = packed struct(u128) { - a: u64, - b: u64, -}; -extern fn c_big_packed_struct(BigPackedStruct) void; -extern fn c_ret_big_packed_struct() BigPackedStruct; - -export fn zig_big_packed_struct(x: BigPackedStruct) void { - expect(x.a == 1) catch @panic("test failure"); - expect(x.b == 2) catch @panic("test failure"); -} - -test "C ABI big packed struct" { - if (!have_i128) return error.SkipZigTest; - - const s = BigPackedStruct{ .a = 1, .b = 2 }; - c_big_packed_struct(s); - const s2 = c_ret_big_packed_struct(); - try expect(s2.a == 1); - try expect(s2.b == 2); -} - -const SplitStructInt = extern struct { - a: u64, - b: u8, - c: u32, -}; -extern fn c_split_struct_ints(SplitStructInt) void; - -test "C ABI split struct of ints" { - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = SplitStructInt{ - .a = 1234, - .b = 100, - .c = 1337, - }; - c_split_struct_ints(s); -} - -export fn zig_split_struct_ints(x: SplitStructInt) void { - expect(x.a == 1234) catch @panic("test failure"); - expect(x.b == 100) catch @panic("test failure"); - expect(x.c == 1337) catch @panic("test failure"); -} - -const SplitStructMixed = extern struct { - a: u64, - b: u8, - c: f32, -}; -extern fn c_split_struct_mixed(SplitStructMixed) void; -extern fn c_ret_split_struct_mixed() SplitStructMixed; - -test "C ABI split struct of ints and floats" { - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = SplitStructMixed{ - .a = 1234, - .b = 100, - .c = 1337.0, - }; - c_split_struct_mixed(s); - const s2 = c_ret_split_struct_mixed(); - try expect(s2.a == 1234); - try expect(s2.b == 100); - try expect(s2.c == 1337.0); -} - -export fn zig_split_struct_mixed(x: SplitStructMixed) void { - expect(x.a == 1234) catch @panic("test failure"); - expect(x.b == 100) catch @panic("test failure"); - expect(x.c == 1337.0) catch @panic("test failure"); -} - -extern fn c_big_struct_both(BigStruct) BigStruct; - -extern fn c_multiple_struct_ints(Rect, Rect) void; -extern fn c_multiple_struct_floats(FloatRect, FloatRect) void; - -test "C ABI sret and byval together" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const s = BigStruct{ - .a = 1, - .b = 2, - .c = 3, - .d = 4, - .e = 5, - }; - const y = c_big_struct_both(s); - try expect(y.a == 10); - try expect(y.b == 11); - try expect(y.c == 12); - try expect(y.d == 13); - try expect(y.e == 14); -} - -export fn zig_big_struct_both(x: BigStruct) BigStruct { - expect(x.a == 30) catch @panic("test failure"); - expect(x.b == 31) catch @panic("test failure"); - expect(x.c == 32) catch @panic("test failure"); - expect(x.d == 33) catch @panic("test failure"); - expect(x.e == 34) catch @panic("test failure"); - const s = BigStruct{ - .a = 20, - .b = 21, - .c = 22, - .d = 23, - .e = 24, - }; - return s; -} - -const Vector3 = extern struct { - x: f32, - y: f32, - z: f32, -}; -extern fn c_small_struct_floats(Vector3) void; -extern fn c_small_struct_floats_extra(Vector3, ?[*]const u8) void; - -const Vector5 = extern struct { - x: f32, - y: f32, - z: f32, - w: f32, - q: f32, -}; -extern fn c_big_struct_floats(Vector5) void; - -test "C ABI structs of floats as parameter" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const v3 = Vector3{ - .x = 3.0, - .y = 6.0, - .z = 12.0, - }; - c_small_struct_floats(v3); - c_small_struct_floats_extra(v3, "hello"); - - const v5 = Vector5{ - .x = 76.0, - .y = -1.0, - .z = -12.0, - .w = 69.0, - .q = 55, - }; - c_big_struct_floats(v5); -} - -const Rect = extern struct { - left: u32, - right: u32, - top: u32, - bottom: u32, -}; - -export fn zig_multiple_struct_ints(x: Rect, y: Rect) void { - expect(x.left == 1) catch @panic("test failure"); - expect(x.right == 21) catch @panic("test failure"); - expect(x.top == 16) catch @panic("test failure"); - expect(x.bottom == 4) catch @panic("test failure"); - expect(y.left == 178) catch @panic("test failure"); - expect(y.right == 189) catch @panic("test failure"); - expect(y.top == 21) catch @panic("test failure"); - expect(y.bottom == 15) catch @panic("test failure"); -} - -test "C ABI structs of ints as multiple parameters" { - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const r1 = Rect{ - .left = 1, - .right = 21, - .top = 16, - .bottom = 4, - }; - const r2 = Rect{ - .left = 178, - .right = 189, - .top = 21, - .bottom = 15, - }; - c_multiple_struct_ints(r1, r2); -} - -const FloatRect = extern struct { - left: f32, - right: f32, - top: f32, - bottom: f32, -}; - -export fn zig_multiple_struct_floats(x: FloatRect, y: FloatRect) void { - expect(x.left == 1) catch @panic("test failure"); - expect(x.right == 21) catch @panic("test failure"); - expect(x.top == 16) catch @panic("test failure"); - expect(x.bottom == 4) catch @panic("test failure"); - expect(y.left == 178) catch @panic("test failure"); - expect(y.right == 189) catch @panic("test failure"); - expect(y.top == 21) catch @panic("test failure"); - expect(y.bottom == 15) catch @panic("test failure"); -} - -test "C ABI structs of floats as multiple parameters" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - const r1 = FloatRect{ - .left = 1, - .right = 21, - .top = 16, - .bottom = 4, - }; - const r2 = FloatRect{ - .left = 178, - .right = 189, - .top = 21, - .bottom = 15, - }; - c_multiple_struct_floats(r1, r2); -} - -export fn zig_ret_bool() bool { - return true; -} -export fn zig_ret_u8() u8 { - return 0xff; -} -export fn zig_ret_u16() u16 { - return 0xffff; -} -export fn zig_ret_u32() u32 { - return 0xffffffff; -} -export fn zig_ret_u64() u64 { - return 0xffffffffffffffff; -} -export fn zig_ret_i8() i8 { - return -1; -} -export fn zig_ret_i16() i16 { - return -1; -} -export fn zig_ret_i32() i32 { - return -1; -} -export fn zig_ret_i64() i64 { - return -1; -} - -export fn zig_ret_small_struct_ints() SmallStructInts { - return .{ - .a = 1, - .b = 2, - .c = 3, - .d = 4, - }; -} - -export fn zig_ret_med_struct_ints() MedStructInts { - return .{ - .x = 1, - .y = 2, - .z = 3, - }; -} - -export fn zig_ret_med_struct_mixed() MedStructMixed { - return .{ - .a = 1234, - .b = 100.0, - .c = 1337.0, - }; -} - -export fn zig_ret_split_struct_mixed() SplitStructMixed { - return .{ - .a = 1234, - .b = 100, - .c = 1337.0, - }; -} - -extern fn c_ret_bool() bool; -extern fn c_ret_u8() u8; -extern fn c_ret_u16() u16; -extern fn c_ret_u32() u32; -extern fn c_ret_u64() u64; -extern fn c_ret_i8() i8; -extern fn c_ret_i16() i16; -extern fn c_ret_i32() i32; -extern fn c_ret_i64() i64; - -test "C ABI integer return types" { - try expect(c_ret_bool() == true); - - try expect(c_ret_u8() == 0xff); - try expect(c_ret_u16() == 0xffff); - try expect(c_ret_u32() == 0xffffffff); - try expect(c_ret_u64() == 0xffffffffffffffff); - - try expect(c_ret_i8() == -1); - try expect(c_ret_i16() == -1); - try expect(c_ret_i32() == -1); - try expect(c_ret_i64() == -1); -} - -const StructWithArray = extern struct { - a: i32, - padding: [4]u8, - b: i64, -}; -extern fn c_struct_with_array(StructWithArray) void; -extern fn c_ret_struct_with_array() StructWithArray; - -test "Struct with array as padding." { - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 }); - - const x = c_ret_struct_with_array(); - try expect(x.a == 4); - try expect(x.b == 155); -} - -const FloatArrayStruct = extern struct { - origin: extern struct { - x: f64, - y: f64, - }, - size: extern struct { - width: f64, - height: f64, - }, -}; - -extern fn c_float_array_struct(FloatArrayStruct) void; -extern fn c_ret_float_array_struct() FloatArrayStruct; - -test "Float array like struct" { - if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - c_float_array_struct(.{ - .origin = .{ - .x = 5, - .y = 6, - }, - .size = .{ - .width = 7, - .height = 8, - }, - }); - - const x = c_ret_float_array_struct(); - try expect(x.origin.x == 1); - try expect(x.origin.y == 2); - try expect(x.size.width == 3); - try expect(x.size.height == 4); -} - -const SmallVec = @Vector(2, u32); - -extern fn c_small_vec(SmallVec) void; -extern fn c_ret_small_vec() SmallVec; - -test "small simd vector" { - if (builtin.cpu.arch == .x86) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - c_small_vec(.{ 1, 2 }); - - const x = c_ret_small_vec(); - try expect(x[0] == 3); - try expect(x[1] == 4); -} - -const MediumVec = @Vector(4, usize); - -extern fn c_medium_vec(MediumVec) void; -extern fn c_ret_medium_vec() MediumVec; - -test "medium simd vector" { - if (builtin.zig_backend == .stage2_x86_64 and !comptime builtin.cpu.has(.x86, .avx)) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - c_medium_vec(.{ 1, 2, 3, 4 }); - - const x = c_ret_medium_vec(); - try expect(x[0] == 5); - try expect(x[1] == 6); - try expect(x[2] == 7); - try expect(x[3] == 8); -} - -const BigVec = @Vector(8, usize); - -extern fn c_big_vec(BigVec) void; -extern fn c_ret_big_vec() BigVec; - -test "big simd vector" { - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; - - if (builtin.cpu.arch.isMIPS64() and builtin.mode != .Debug) return error.SkipZigTest; - if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag.isDarwin() and builtin.mode != .Debug) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - c_big_vec(.{ 1, 2, 3, 4, 5, 6, 7, 8 }); - - const x = c_ret_big_vec(); - try expect(x[0] == 9); - try expect(x[1] == 10); - try expect(x[2] == 11); - try expect(x[3] == 12); - try expect(x[4] == 13); - try expect(x[5] == 14); - try expect(x[6] == 15); - try expect(x[7] == 16); -} - -const Vector2Float = @Vector(2, f32); -const Vector4Float = @Vector(4, f32); - -extern fn c_vector_2_float(Vector2Float) void; -extern fn c_vector_4_float(Vector4Float) void; - -extern fn c_ret_vector_2_float() Vector2Float; -extern fn c_ret_vector_4_float() Vector4Float; - -test "float simd vectors" { - if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; - if (builtin.cpu.arch == .s390x) return error.SkipZigTest; - - { - c_vector_2_float(.{ 1.0, 2.0 }); - const vec = c_ret_vector_2_float(); - try expect(vec[0] == 1.0); - try expect(vec[1] == 2.0); - } - { - c_vector_4_float(.{ 1.0, 2.0, 3.0, 4.0 }); - const vec = c_ret_vector_4_float(); - try expect(vec[0] == 1.0); - try expect(vec[1] == 2.0); - try expect(vec[2] == 3.0); - try expect(vec[3] == 4.0); - } -} - -const Vector2Bool = @Vector(2, bool); -const Vector4Bool = @Vector(4, bool); -const Vector8Bool = @Vector(8, bool); -const Vector16Bool = @Vector(16, bool); -const Vector32Bool = @Vector(32, bool); -const Vector64Bool = @Vector(64, bool); -const Vector128Bool = @Vector(128, bool); -const Vector256Bool = @Vector(256, bool); -const Vector512Bool = @Vector(512, bool); - -extern fn c_vector_2_bool(Vector2Bool) void; -extern fn c_vector_4_bool(Vector4Bool) void; -extern fn c_vector_8_bool(Vector8Bool) void; -extern fn c_vector_16_bool(Vector16Bool) void; -extern fn c_vector_32_bool(Vector32Bool) void; -extern fn c_vector_64_bool(Vector64Bool) void; -extern fn c_vector_128_bool(Vector128Bool) void; -extern fn c_vector_256_bool(Vector256Bool) void; -extern fn c_vector_512_bool(Vector512Bool) void; - -extern fn c_ret_vector_2_bool() Vector2Bool; -extern fn c_ret_vector_4_bool() Vector4Bool; -extern fn c_ret_vector_8_bool() Vector8Bool; -extern fn c_ret_vector_16_bool() Vector16Bool; -extern fn c_ret_vector_32_bool() Vector32Bool; -extern fn c_ret_vector_64_bool() Vector64Bool; -extern fn c_ret_vector_128_bool() Vector128Bool; -extern fn c_ret_vector_256_bool() Vector256Bool; -extern fn c_ret_vector_512_bool() Vector512Bool; - -test "bool simd vector" { - if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - - { - c_vector_2_bool(.{ - true, - true, - }); - - const vec = c_ret_vector_2_bool(); - try expect(vec[0] == true); - try expect(vec[1] == false); - } - { - c_vector_4_bool(.{ - true, - true, - false, - true, - }); - - const vec = c_ret_vector_4_bool(); - try expect(vec[0] == true); - try expect(vec[1] == false); - try expect(vec[2] == true); - try expect(vec[3] == false); - } - { - c_vector_8_bool(.{ - true, - false, - true, - true, - true, - true, - false, - true, - }); - - const vec = c_ret_vector_8_bool(); - try expect(vec[0] == false); - try expect(vec[1] == true); - try expect(vec[2] == false); - try expect(vec[3] == false); - try expect(vec[4] == true); - try expect(vec[5] == false); - try expect(vec[6] == false); - try expect(vec[7] == true); - } - { - c_vector_16_bool(.{ - true, - false, - false, - false, - true, - false, - true, - true, - true, - true, - true, - true, - false, - false, - false, - false, - }); - - const vec = c_ret_vector_16_bool(); - try expect(vec[0] == true); - try expect(vec[1] == true); - try expect(vec[2] == false); - try expect(vec[3] == false); - try expect(vec[4] == false); - try expect(vec[5] == false); - try expect(vec[6] == true); - try expect(vec[7] == false); - try expect(vec[8] == true); - try expect(vec[9] == false); - try expect(vec[10] == false); - try expect(vec[11] == true); - try expect(vec[12] == true); - try expect(vec[13] == false); - try expect(vec[14] == true); - try expect(vec[15] == true); - } - { - c_vector_32_bool(.{ - true, - false, - true, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - }); - - const vec = c_ret_vector_32_bool(); - try expect(vec[0] == true); - try expect(vec[1] == false); - try expect(vec[2] == true); - try expect(vec[3] == true); - try expect(vec[4] == true); - try expect(vec[5] == false); - try expect(vec[6] == true); - try expect(vec[7] == false); - try expect(vec[8] == true); - try expect(vec[9] == true); - try expect(vec[10] == true); - try expect(vec[11] == false); - try expect(vec[12] == true); - try expect(vec[13] == true); - try expect(vec[14] == false); - try expect(vec[15] == false); - try expect(vec[16] == true); - try expect(vec[17] == false); - try expect(vec[18] == false); - try expect(vec[19] == false); - try expect(vec[20] == false); - try expect(vec[21] == true); - try expect(vec[22] == true); - try expect(vec[23] == true); - try expect(vec[24] == false); - try expect(vec[25] == true); - try expect(vec[26] == false); - try expect(vec[27] == false); - try expect(vec[28] == true); - try expect(vec[29] == false); - try expect(vec[30] == false); - try expect(vec[31] == false); - } - { - c_vector_64_bool(.{ - true, - true, - true, - false, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - false, - false, - true, - true, - false, - true, - false, - false, - true, - true, - true, - false, - false, - true, - true, - false, - true, - false, - true, - false, - false, - true, - false, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - false, - }); - - const vec = c_ret_vector_64_bool(); - try expect(vec[0] == false); - try expect(vec[1] == true); - try expect(vec[2] == false); - try expect(vec[3] == true); - try expect(vec[4] == true); - try expect(vec[5] == true); - try expect(vec[6] == false); - try expect(vec[7] == true); - try expect(vec[8] == true); - try expect(vec[9] == true); - try expect(vec[10] == true); - try expect(vec[11] == true); - try expect(vec[12] == true); - try expect(vec[13] == false); - try expect(vec[14] == true); - try expect(vec[15] == true); - try expect(vec[16] == true); - try expect(vec[17] == false); - try expect(vec[18] == false); - try expect(vec[19] == false); - try expect(vec[20] == true); - try expect(vec[21] == true); - try expect(vec[22] == false); - try expect(vec[23] == true); - try expect(vec[24] == false); - try expect(vec[25] == true); - try expect(vec[26] == false); - try expect(vec[27] == true); - try expect(vec[28] == false); - try expect(vec[29] == true); - try expect(vec[30] == false); - try expect(vec[31] == true); - try expect(vec[32] == false); - try expect(vec[33] == false); - try expect(vec[34] == true); - try expect(vec[35] == true); - try expect(vec[36] == false); - try expect(vec[37] == false); - try expect(vec[38] == false); - try expect(vec[39] == true); - try expect(vec[40] == true); - try expect(vec[41] == true); - try expect(vec[42] == true); - try expect(vec[43] == false); - try expect(vec[44] == false); - try expect(vec[45] == false); - try expect(vec[46] == true); - try expect(vec[47] == true); - try expect(vec[48] == false); - try expect(vec[49] == false); - try expect(vec[50] == true); - try expect(vec[51] == false); - try expect(vec[52] == false); - try expect(vec[53] == false); - try expect(vec[54] == false); - try expect(vec[55] == true); - try expect(vec[56] == false); - try expect(vec[57] == false); - try expect(vec[58] == false); - try expect(vec[59] == true); - try expect(vec[60] == true); - try expect(vec[61] == true); - try expect(vec[62] == true); - try expect(vec[63] == true); - } - { - c_vector_128_bool(.{ - false, - false, - false, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - true, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - false, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - true, - false, - true, - false, - false, - false, - false, - true, - false, - false, - false, - true, - true, - false, - false, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - }); - - const vec = c_ret_vector_128_bool(); - try expect(vec[0] == false); - try expect(vec[1] == true); - try expect(vec[2] == true); - try expect(vec[3] == false); - try expect(vec[4] == true); - try expect(vec[5] == false); - try expect(vec[6] == false); - try expect(vec[7] == true); - try expect(vec[8] == true); - try expect(vec[9] == false); - try expect(vec[10] == true); - try expect(vec[11] == false); - try expect(vec[12] == false); - try expect(vec[13] == false); - try expect(vec[14] == true); - try expect(vec[15] == false); - try expect(vec[16] == true); - try expect(vec[17] == false); - try expect(vec[18] == false); - try expect(vec[19] == true); - try expect(vec[20] == false); - try expect(vec[21] == true); - try expect(vec[22] == false); - try expect(vec[23] == false); - try expect(vec[24] == false); - try expect(vec[25] == true); - try expect(vec[26] == true); - try expect(vec[27] == true); - try expect(vec[28] == false); - try expect(vec[29] == false); - try expect(vec[30] == false); - try expect(vec[31] == false); - try expect(vec[32] == true); - try expect(vec[33] == true); - try expect(vec[34] == true); - try expect(vec[35] == false); - try expect(vec[36] == true); - try expect(vec[37] == true); - try expect(vec[38] == false); - try expect(vec[39] == false); - try expect(vec[40] == false); - try expect(vec[41] == false); - try expect(vec[42] == true); - try expect(vec[43] == true); - try expect(vec[44] == true); - try expect(vec[45] == false); - try expect(vec[46] == false); - try expect(vec[47] == false); - try expect(vec[48] == false); - try expect(vec[49] == true); - try expect(vec[50] == false); - try expect(vec[51] == false); - try expect(vec[52] == true); - try expect(vec[53] == false); - try expect(vec[54] == false); - try expect(vec[55] == false); - try expect(vec[56] == false); - try expect(vec[57] == false); - try expect(vec[58] == true); - try expect(vec[59] == true); - try expect(vec[60] == true); - try expect(vec[61] == false); - try expect(vec[62] == true); - try expect(vec[63] == true); - try expect(vec[64] == false); - try expect(vec[65] == false); - try expect(vec[66] == false); - try expect(vec[67] == false); - try expect(vec[68] == false); - try expect(vec[69] == false); - try expect(vec[70] == false); - try expect(vec[71] == false); - try expect(vec[72] == true); - try expect(vec[73] == true); - try expect(vec[74] == true); - try expect(vec[75] == true); - try expect(vec[76] == true); - try expect(vec[77] == false); - try expect(vec[78] == false); - try expect(vec[79] == false); - try expect(vec[80] == false); - try expect(vec[81] == false); - try expect(vec[82] == false); - try expect(vec[83] == true); - try expect(vec[84] == false); - try expect(vec[85] == true); - try expect(vec[86] == false); - try expect(vec[87] == true); - try expect(vec[88] == false); - try expect(vec[89] == true); - try expect(vec[90] == false); - try expect(vec[91] == true); - try expect(vec[92] == true); - try expect(vec[93] == true); - try expect(vec[94] == true); - try expect(vec[95] == false); - try expect(vec[96] == false); - try expect(vec[97] == true); - try expect(vec[98] == false); - try expect(vec[99] == false); - try expect(vec[100] == true); - try expect(vec[101] == true); - try expect(vec[102] == true); - try expect(vec[103] == true); - try expect(vec[104] == false); - try expect(vec[105] == true); - try expect(vec[106] == true); - try expect(vec[107] == true); - try expect(vec[108] == false); - try expect(vec[109] == false); - try expect(vec[110] == true); - try expect(vec[111] == false); - try expect(vec[112] == false); - try expect(vec[113] == true); - try expect(vec[114] == true); - try expect(vec[115] == false); - try expect(vec[116] == true); - try expect(vec[117] == false); - try expect(vec[118] == true); - try expect(vec[119] == true); - try expect(vec[120] == true); - try expect(vec[121] == true); - try expect(vec[122] == true); - try expect(vec[123] == false); - try expect(vec[124] == false); - try expect(vec[125] == true); - try expect(vec[126] == false); - try expect(vec[127] == true); - } - - { - if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{ - false, - true, - true, - false, - false, - true, - true, - true, - false, - true, - true, - true, - false, - true, - false, - true, - false, - false, - true, - true, - false, - true, - false, - false, - false, - true, - true, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - false, - false, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - false, - true, - true, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - false, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - true, - false, - true, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - true, - false, - true, - true, - true, - false, - false, - true, - true, - true, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - false, - false, - false, - true, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - true, - false, - true, - true, - true, - false, - }); - - const vec = c_ret_vector_256_bool(); - try expect(vec[0] == true); - try expect(vec[1] == false); - try expect(vec[2] == true); - try expect(vec[3] == true); - try expect(vec[4] == false); - try expect(vec[5] == false); - try expect(vec[6] == false); - try expect(vec[7] == false); - try expect(vec[8] == false); - try expect(vec[9] == true); - try expect(vec[10] == false); - try expect(vec[11] == true); - try expect(vec[12] == false); - try expect(vec[13] == true); - try expect(vec[14] == false); - try expect(vec[15] == false); - try expect(vec[16] == true); - try expect(vec[17] == true); - try expect(vec[18] == true); - try expect(vec[19] == false); - try expect(vec[20] == false); - try expect(vec[21] == false); - try expect(vec[22] == true); - try expect(vec[23] == false); - try expect(vec[24] == true); - try expect(vec[25] == false); - try expect(vec[26] == false); - try expect(vec[27] == true); - try expect(vec[28] == true); - try expect(vec[29] == true); - try expect(vec[30] == false); - try expect(vec[31] == false); - try expect(vec[32] == true); - try expect(vec[33] == true); - try expect(vec[34] == true); - try expect(vec[35] == false); - try expect(vec[36] == true); - try expect(vec[37] == true); - try expect(vec[38] == true); - try expect(vec[39] == false); - try expect(vec[40] == true); - try expect(vec[41] == false); - try expect(vec[42] == true); - try expect(vec[43] == true); - try expect(vec[44] == false); - try expect(vec[45] == true); - try expect(vec[46] == false); - try expect(vec[47] == true); - try expect(vec[48] == true); - try expect(vec[49] == false); - try expect(vec[50] == false); - try expect(vec[51] == true); - try expect(vec[52] == true); - try expect(vec[53] == false); - try expect(vec[54] == false); - try expect(vec[55] == true); - try expect(vec[56] == false); - try expect(vec[57] == true); - try expect(vec[58] == true); - try expect(vec[59] == true); - try expect(vec[60] == false); - try expect(vec[61] == true); - try expect(vec[62] == true); - try expect(vec[63] == false); - try expect(vec[64] == true); - try expect(vec[65] == true); - try expect(vec[66] == false); - try expect(vec[67] == true); - try expect(vec[68] == false); - try expect(vec[69] == true); - try expect(vec[70] == true); - try expect(vec[71] == true); - try expect(vec[72] == false); - try expect(vec[73] == true); - try expect(vec[74] == true); - try expect(vec[75] == false); - try expect(vec[76] == true); - try expect(vec[77] == true); - try expect(vec[78] == true); - try expect(vec[79] == true); - try expect(vec[80] == false); - try expect(vec[81] == true); - try expect(vec[82] == false); - try expect(vec[83] == true); - try expect(vec[84] == true); - try expect(vec[85] == true); - try expect(vec[86] == false); - try expect(vec[87] == true); - try expect(vec[88] == false); - try expect(vec[89] == true); - try expect(vec[90] == false); - try expect(vec[91] == false); - try expect(vec[92] == true); - try expect(vec[93] == false); - try expect(vec[94] == false); - try expect(vec[95] == false); - try expect(vec[96] == true); - try expect(vec[97] == true); - try expect(vec[98] == false); - try expect(vec[99] == false); - try expect(vec[100] == false); - try expect(vec[101] == true); - try expect(vec[102] == true); - try expect(vec[103] == true); - try expect(vec[104] == false); - try expect(vec[105] == false); - try expect(vec[106] == false); - try expect(vec[107] == true); - try expect(vec[108] == false); - try expect(vec[109] == true); - try expect(vec[110] == true); - try expect(vec[111] == true); - try expect(vec[112] == true); - try expect(vec[113] == true); - try expect(vec[114] == true); - try expect(vec[115] == true); - try expect(vec[116] == true); - try expect(vec[117] == false); - try expect(vec[118] == true); - try expect(vec[119] == false); - try expect(vec[120] == true); - try expect(vec[121] == false); - try expect(vec[122] == false); - try expect(vec[123] == true); - try expect(vec[124] == true); - try expect(vec[125] == false); - try expect(vec[126] == true); - try expect(vec[127] == false); - try expect(vec[128] == false); - try expect(vec[129] == false); - try expect(vec[130] == false); - try expect(vec[131] == true); - try expect(vec[132] == false); - try expect(vec[133] == false); - try expect(vec[134] == true); - try expect(vec[135] == false); - try expect(vec[136] == false); - try expect(vec[137] == false); - try expect(vec[138] == false); - try expect(vec[139] == false); - try expect(vec[140] == false); - try expect(vec[141] == true); - try expect(vec[142] == false); - try expect(vec[143] == true); - try expect(vec[144] == false); - try expect(vec[145] == true); - try expect(vec[146] == true); - try expect(vec[147] == true); - try expect(vec[148] == false); - try expect(vec[149] == true); - try expect(vec[150] == true); - try expect(vec[151] == false); - try expect(vec[152] == true); - try expect(vec[153] == true); - try expect(vec[154] == false); - try expect(vec[155] == true); - try expect(vec[156] == true); - try expect(vec[157] == true); - try expect(vec[158] == true); - try expect(vec[159] == true); - try expect(vec[160] == true); - try expect(vec[161] == true); - try expect(vec[162] == false); - try expect(vec[163] == false); - try expect(vec[164] == false); - try expect(vec[165] == true); - try expect(vec[166] == false); - try expect(vec[167] == false); - try expect(vec[168] == true); - try expect(vec[169] == false); - try expect(vec[170] == true); - try expect(vec[171] == true); - try expect(vec[172] == true); - try expect(vec[173] == false); - try expect(vec[174] == false); - try expect(vec[175] == true); - try expect(vec[176] == true); - try expect(vec[177] == true); - try expect(vec[178] == true); - try expect(vec[179] == false); - try expect(vec[180] == true); - try expect(vec[181] == true); - try expect(vec[182] == false); - try expect(vec[183] == true); - try expect(vec[184] == false); - try expect(vec[185] == false); - try expect(vec[186] == false); - try expect(vec[187] == true); - try expect(vec[188] == true); - try expect(vec[189] == true); - try expect(vec[190] == true); - try expect(vec[191] == true); - try expect(vec[192] == true); - try expect(vec[193] == true); - try expect(vec[194] == true); - try expect(vec[195] == false); - try expect(vec[196] == false); - try expect(vec[197] == true); - try expect(vec[198] == false); - try expect(vec[199] == false); - try expect(vec[200] == false); - try expect(vec[201] == true); - try expect(vec[202] == true); - try expect(vec[203] == true); - try expect(vec[204] == true); - try expect(vec[205] == true); - try expect(vec[206] == true); - try expect(vec[207] == false); - try expect(vec[208] == false); - try expect(vec[209] == false); - try expect(vec[210] == true); - try expect(vec[211] == true); - try expect(vec[212] == true); - try expect(vec[213] == false); - try expect(vec[214] == true); - try expect(vec[215] == false); - try expect(vec[216] == true); - try expect(vec[217] == false); - try expect(vec[218] == true); - try expect(vec[219] == false); - try expect(vec[220] == true); - try expect(vec[221] == true); - try expect(vec[222] == true); - try expect(vec[223] == false); - try expect(vec[224] == true); - try expect(vec[225] == false); - try expect(vec[226] == true); - try expect(vec[227] == false); - try expect(vec[228] == true); - try expect(vec[229] == false); - try expect(vec[230] == true); - try expect(vec[231] == false); - try expect(vec[232] == false); - try expect(vec[233] == true); - try expect(vec[234] == false); - try expect(vec[235] == true); - try expect(vec[236] == true); - try expect(vec[237] == false); - try expect(vec[238] == false); - try expect(vec[239] == true); - try expect(vec[240] == false); - try expect(vec[241] == false); - try expect(vec[242] == false); - try expect(vec[243] == true); - try expect(vec[244] == true); - try expect(vec[245] == false); - try expect(vec[246] == false); - try expect(vec[247] == false); - try expect(vec[248] == false); - try expect(vec[249] == false); - try expect(vec[250] == true); - try expect(vec[251] == false); - try expect(vec[252] == true); - try expect(vec[253] == false); - try expect(vec[254] == false); - try expect(vec[255] == false); - } - { - if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{ - true, - true, - true, - true, - true, - false, - false, - true, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - true, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - true, - false, - true, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - true, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - false, - false, - true, - true, - true, - false, - true, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - true, - false, - true, - true, - true, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - false, - true, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - true, - true, - false, - false, - true, - true, - true, - true, - false, - false, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - true, - false, - true, - true, - true, - false, - false, - true, - false, - true, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - false, - false, - true, - false, - false, - true, - true, - false, - false, - false, - false, - true, - true, - true, - true, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - false, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - true, - true, - false, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - true, - false, - true, - false, - true, - }); - - const vec = c_ret_vector_512_bool(); - try expect(vec[0] == false); - try expect(vec[1] == true); - try expect(vec[2] == false); - try expect(vec[3] == false); - try expect(vec[4] == false); - try expect(vec[5] == true); - try expect(vec[6] == false); - try expect(vec[7] == false); - try expect(vec[8] == false); - try expect(vec[9] == true); - try expect(vec[10] == false); - try expect(vec[11] == false); - try expect(vec[12] == false); - try expect(vec[13] == true); - try expect(vec[14] == false); - try expect(vec[15] == true); - try expect(vec[16] == false); - try expect(vec[17] == false); - try expect(vec[18] == false); - try expect(vec[19] == false); - try expect(vec[20] == false); - try expect(vec[21] == false); - try expect(vec[22] == true); - try expect(vec[23] == true); - try expect(vec[24] == false); - try expect(vec[25] == false); - try expect(vec[26] == false); - try expect(vec[27] == false); - try expect(vec[28] == true); - try expect(vec[29] == true); - try expect(vec[30] == false); - try expect(vec[31] == true); - try expect(vec[32] == false); - try expect(vec[33] == true); - try expect(vec[34] == true); - try expect(vec[35] == true); - try expect(vec[36] == false); - try expect(vec[37] == false); - try expect(vec[38] == true); - try expect(vec[39] == true); - try expect(vec[40] == false); - try expect(vec[41] == false); - try expect(vec[42] == false); - try expect(vec[43] == false); - try expect(vec[44] == false); - try expect(vec[45] == true); - try expect(vec[46] == false); - try expect(vec[47] == true); - try expect(vec[48] == true); - try expect(vec[49] == false); - try expect(vec[50] == true); - try expect(vec[51] == true); - try expect(vec[52] == true); - try expect(vec[53] == true); - try expect(vec[54] == false); - try expect(vec[55] == false); - try expect(vec[56] == false); - try expect(vec[57] == true); - try expect(vec[58] == true); - try expect(vec[59] == false); - try expect(vec[60] == false); - try expect(vec[61] == false); - try expect(vec[62] == false); - try expect(vec[63] == true); - try expect(vec[64] == true); - try expect(vec[65] == true); - try expect(vec[66] == true); - try expect(vec[67] == true); - try expect(vec[68] == false); - try expect(vec[69] == false); - try expect(vec[70] == false); - try expect(vec[71] == false); - try expect(vec[72] == false); - try expect(vec[73] == true); - try expect(vec[74] == false); - try expect(vec[75] == true); - try expect(vec[76] == false); - try expect(vec[77] == false); - try expect(vec[78] == true); - try expect(vec[79] == true); - try expect(vec[80] == false); - try expect(vec[81] == false); - try expect(vec[82] == false); - try expect(vec[83] == true); - try expect(vec[84] == false); - try expect(vec[85] == true); - try expect(vec[86] == true); - try expect(vec[87] == true); - try expect(vec[88] == false); - try expect(vec[89] == true); - try expect(vec[90] == false); - try expect(vec[91] == false); - try expect(vec[92] == true); - try expect(vec[93] == true); - try expect(vec[94] == false); - try expect(vec[95] == true); - try expect(vec[96] == true); - try expect(vec[97] == false); - try expect(vec[98] == true); - try expect(vec[99] == false); - try expect(vec[100] == true); - try expect(vec[101] == true); - try expect(vec[102] == false); - try expect(vec[103] == true); - try expect(vec[104] == true); - try expect(vec[105] == false); - try expect(vec[106] == false); - try expect(vec[107] == false); - try expect(vec[108] == true); - try expect(vec[109] == false); - try expect(vec[110] == false); - try expect(vec[111] == false); - try expect(vec[112] == true); - try expect(vec[113] == true); - try expect(vec[114] == true); - try expect(vec[115] == false); - try expect(vec[116] == true); - try expect(vec[117] == false); - try expect(vec[118] == true); - try expect(vec[119] == false); - try expect(vec[120] == true); - try expect(vec[121] == true); - try expect(vec[122] == false); - try expect(vec[123] == true); - try expect(vec[124] == false); - try expect(vec[125] == true); - try expect(vec[126] == true); - try expect(vec[127] == true); - try expect(vec[128] == false); - try expect(vec[129] == true); - try expect(vec[130] == false); - try expect(vec[131] == false); - try expect(vec[132] == false); - try expect(vec[133] == false); - try expect(vec[134] == false); - try expect(vec[135] == false); - try expect(vec[136] == true); - try expect(vec[137] == false); - try expect(vec[138] == true); - try expect(vec[139] == false); - try expect(vec[140] == true); - try expect(vec[141] == true); - try expect(vec[142] == false); - try expect(vec[143] == true); - try expect(vec[144] == false); - try expect(vec[145] == false); - try expect(vec[146] == true); - try expect(vec[147] == false); - try expect(vec[148] == false); - try expect(vec[149] == true); - try expect(vec[150] == false); - try expect(vec[151] == true); - try expect(vec[152] == false); - try expect(vec[153] == true); - try expect(vec[154] == false); - try expect(vec[155] == false); - try expect(vec[156] == true); - try expect(vec[157] == false); - try expect(vec[158] == true); - try expect(vec[159] == true); - try expect(vec[160] == true); - try expect(vec[161] == false); - try expect(vec[162] == false); - try expect(vec[163] == true); - try expect(vec[164] == false); - try expect(vec[165] == false); - try expect(vec[166] == false); - try expect(vec[167] == true); - try expect(vec[168] == true); - try expect(vec[169] == true); - try expect(vec[170] == false); - try expect(vec[171] == true); - try expect(vec[172] == false); - try expect(vec[173] == false); - try expect(vec[174] == false); - try expect(vec[175] == false); - try expect(vec[176] == false); - try expect(vec[177] == true); - try expect(vec[178] == true); - try expect(vec[179] == false); - try expect(vec[180] == false); - try expect(vec[181] == true); - try expect(vec[182] == false); - try expect(vec[183] == false); - try expect(vec[184] == false); - try expect(vec[185] == false); - try expect(vec[186] == false); - try expect(vec[187] == true); - try expect(vec[188] == true); - try expect(vec[189] == false); - try expect(vec[190] == false); - try expect(vec[191] == false); - try expect(vec[192] == false); - try expect(vec[193] == false); - try expect(vec[194] == false); - try expect(vec[195] == true); - try expect(vec[196] == true); - try expect(vec[197] == false); - try expect(vec[198] == true); - try expect(vec[199] == true); - try expect(vec[200] == true); - try expect(vec[201] == true); - try expect(vec[202] == true); - try expect(vec[203] == true); - try expect(vec[204] == false); - try expect(vec[205] == false); - try expect(vec[206] == false); - try expect(vec[207] == false); - try expect(vec[208] == true); - try expect(vec[209] == false); - try expect(vec[210] == true); - try expect(vec[211] == true); - try expect(vec[212] == true); - try expect(vec[213] == true); - try expect(vec[214] == false); - try expect(vec[215] == false); - try expect(vec[216] == false); - try expect(vec[217] == true); - try expect(vec[218] == true); - try expect(vec[219] == false); - try expect(vec[220] == true); - try expect(vec[221] == true); - try expect(vec[222] == false); - try expect(vec[223] == false); - try expect(vec[224] == false); - try expect(vec[225] == true); - try expect(vec[226] == true); - try expect(vec[227] == true); - try expect(vec[228] == true); - try expect(vec[229] == false); - try expect(vec[230] == true); - try expect(vec[231] == false); - try expect(vec[232] == true); - try expect(vec[233] == true); - try expect(vec[234] == true); - try expect(vec[235] == true); - try expect(vec[236] == false); - try expect(vec[237] == true); - try expect(vec[238] == false); - try expect(vec[239] == true); - try expect(vec[240] == false); - try expect(vec[241] == true); - try expect(vec[242] == false); - try expect(vec[243] == false); - try expect(vec[244] == false); - try expect(vec[245] == true); - try expect(vec[246] == true); - try expect(vec[247] == false); - try expect(vec[248] == true); - try expect(vec[249] == false); - try expect(vec[250] == false); - try expect(vec[251] == false); - try expect(vec[252] == true); - try expect(vec[253] == true); - try expect(vec[254] == true); - try expect(vec[255] == true); - try expect(vec[256] == true); - try expect(vec[257] == false); - try expect(vec[258] == true); - try expect(vec[259] == true); - try expect(vec[260] == true); - try expect(vec[261] == true); - try expect(vec[262] == false); - try expect(vec[263] == true); - try expect(vec[264] == false); - try expect(vec[265] == false); - try expect(vec[266] == true); - try expect(vec[267] == false); - try expect(vec[268] == true); - try expect(vec[269] == false); - try expect(vec[270] == false); - try expect(vec[271] == true); - try expect(vec[272] == true); - try expect(vec[273] == false); - try expect(vec[274] == true); - try expect(vec[275] == false); - try expect(vec[276] == false); - try expect(vec[277] == true); - try expect(vec[278] == false); - try expect(vec[279] == false); - try expect(vec[280] == true); - try expect(vec[281] == true); - try expect(vec[282] == true); - try expect(vec[283] == false); - try expect(vec[284] == false); - try expect(vec[285] == true); - try expect(vec[286] == true); - try expect(vec[287] == true); - try expect(vec[288] == false); - try expect(vec[289] == false); - try expect(vec[290] == false); - try expect(vec[291] == false); - try expect(vec[292] == false); - try expect(vec[293] == false); - try expect(vec[294] == true); - try expect(vec[295] == false); - try expect(vec[296] == true); - try expect(vec[297] == false); - try expect(vec[298] == true); - try expect(vec[299] == true); - try expect(vec[300] == false); - try expect(vec[301] == false); - try expect(vec[302] == false); - try expect(vec[303] == false); - try expect(vec[304] == true); - try expect(vec[305] == true); - try expect(vec[306] == true); - try expect(vec[307] == true); - try expect(vec[308] == true); - try expect(vec[309] == false); - try expect(vec[310] == true); - try expect(vec[311] == true); - try expect(vec[312] == true); - try expect(vec[313] == true); - try expect(vec[314] == true); - try expect(vec[315] == false); - try expect(vec[316] == true); - try expect(vec[317] == true); - try expect(vec[318] == true); - try expect(vec[319] == false); - try expect(vec[320] == true); - try expect(vec[321] == false); - try expect(vec[322] == true); - try expect(vec[323] == true); - try expect(vec[324] == true); - try expect(vec[325] == false); - try expect(vec[326] == false); - try expect(vec[327] == true); - try expect(vec[328] == true); - try expect(vec[329] == true); - try expect(vec[330] == false); - try expect(vec[331] == false); - try expect(vec[332] == true); - try expect(vec[333] == true); - try expect(vec[334] == false); - try expect(vec[335] == true); - try expect(vec[336] == true); - try expect(vec[337] == true); - try expect(vec[338] == true); - try expect(vec[339] == true); - try expect(vec[340] == true); - try expect(vec[341] == false); - try expect(vec[342] == true); - try expect(vec[343] == false); - try expect(vec[344] == true); - try expect(vec[345] == false); - try expect(vec[346] == false); - try expect(vec[347] == false); - try expect(vec[348] == false); - try expect(vec[349] == true); - try expect(vec[350] == true); - try expect(vec[351] == true); - try expect(vec[352] == true); - try expect(vec[353] == false); - try expect(vec[354] == true); - try expect(vec[355] == false); - try expect(vec[356] == true); - try expect(vec[357] == true); - try expect(vec[358] == false); - try expect(vec[359] == true); - try expect(vec[360] == false); - try expect(vec[361] == false); - try expect(vec[362] == true); - try expect(vec[363] == false); - try expect(vec[364] == false); - try expect(vec[365] == false); - try expect(vec[366] == false); - try expect(vec[367] == false); - try expect(vec[368] == false); - try expect(vec[369] == false); - try expect(vec[370] == true); - try expect(vec[371] == false); - try expect(vec[372] == true); - try expect(vec[373] == true); - try expect(vec[374] == false); - try expect(vec[375] == false); - try expect(vec[376] == true); - try expect(vec[377] == false); - try expect(vec[378] == false); - try expect(vec[379] == true); - try expect(vec[380] == false); - try expect(vec[381] == false); - try expect(vec[382] == true); - try expect(vec[383] == false); - try expect(vec[384] == false); - try expect(vec[385] == false); - try expect(vec[386] == false); - try expect(vec[387] == true); - try expect(vec[388] == true); - try expect(vec[389] == true); - try expect(vec[390] == true); - try expect(vec[391] == true); - try expect(vec[392] == true); - try expect(vec[393] == true); - try expect(vec[394] == false); - try expect(vec[395] == true); - try expect(vec[396] == true); - try expect(vec[397] == false); - try expect(vec[398] == false); - try expect(vec[399] == false); - try expect(vec[400] == true); - try expect(vec[401] == false); - try expect(vec[402] == true); - try expect(vec[403] == true); - try expect(vec[404] == false); - try expect(vec[405] == true); - try expect(vec[406] == true); - try expect(vec[407] == true); - try expect(vec[408] == true); - try expect(vec[409] == false); - try expect(vec[410] == false); - try expect(vec[411] == false); - try expect(vec[412] == true); - try expect(vec[413] == true); - try expect(vec[414] == false); - try expect(vec[415] == true); - try expect(vec[416] == false); - try expect(vec[417] == true); - try expect(vec[418] == false); - try expect(vec[419] == false); - try expect(vec[420] == false); - try expect(vec[421] == false); - try expect(vec[422] == true); - try expect(vec[423] == true); - try expect(vec[424] == true); - try expect(vec[425] == false); - try expect(vec[426] == true); - try expect(vec[427] == false); - try expect(vec[428] == false); - try expect(vec[429] == false); - try expect(vec[430] == true); - try expect(vec[431] == true); - try expect(vec[432] == false); - try expect(vec[433] == true); - try expect(vec[434] == false); - try expect(vec[435] == false); - try expect(vec[436] == true); - try expect(vec[437] == true); - try expect(vec[438] == true); - try expect(vec[439] == true); - try expect(vec[440] == true); - try expect(vec[441] == true); - try expect(vec[442] == false); - try expect(vec[443] == false); - try expect(vec[444] == false); - try expect(vec[445] == true); - try expect(vec[446] == true); - try expect(vec[447] == true); - try expect(vec[448] == false); - try expect(vec[449] == false); - try expect(vec[450] == false); - try expect(vec[451] == false); - try expect(vec[452] == false); - try expect(vec[453] == false); - try expect(vec[454] == false); - try expect(vec[455] == false); - try expect(vec[456] == false); - try expect(vec[457] == false); - try expect(vec[458] == false); - try expect(vec[459] == true); - try expect(vec[460] == false); - try expect(vec[461] == false); - try expect(vec[462] == false); - try expect(vec[463] == true); - try expect(vec[464] == false); - try expect(vec[465] == false); - try expect(vec[466] == false); - try expect(vec[467] == false); - try expect(vec[468] == true); - try expect(vec[469] == true); - try expect(vec[470] == true); - try expect(vec[471] == true); - try expect(vec[472] == true); - try expect(vec[473] == false); - try expect(vec[474] == false); - try expect(vec[475] == true); - try expect(vec[476] == true); - try expect(vec[477] == true); - try expect(vec[478] == false); - try expect(vec[479] == true); - try expect(vec[480] == true); - try expect(vec[481] == true); - try expect(vec[482] == false); - try expect(vec[483] == true); - try expect(vec[484] == false); - try expect(vec[485] == true); - try expect(vec[486] == false); - try expect(vec[487] == true); - try expect(vec[488] == false); - try expect(vec[489] == true); - try expect(vec[490] == true); - try expect(vec[491] == true); - try expect(vec[492] == true); - try expect(vec[493] == false); - try expect(vec[494] == true); - try expect(vec[495] == true); - try expect(vec[496] == false); - try expect(vec[497] == true); - try expect(vec[498] == false); - try expect(vec[499] == false); - try expect(vec[500] == false); - try expect(vec[501] == false); - try expect(vec[502] == false); - try expect(vec[503] == false); - try expect(vec[504] == false); - try expect(vec[505] == false); - try expect(vec[506] == false); - try expect(vec[507] == true); - try expect(vec[508] == true); - try expect(vec[509] == false); - try expect(vec[510] == true); - try expect(vec[511] == false); - } -} - comptime { skip: { if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; _ = struct { - export fn zig_vector_2_bool(vec: Vector2Bool) void { + export fn zig_ret_vector_2_bool() @Vector(2, bool) { + return .{ + false, + false, + }; + } + export fn zig_vector_2_bool(vec: @Vector(2, bool)) void { expect(vec[0] == false) catch @panic("test failure"); expect(vec[1] == true) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_4_bool(vec: Vector4Bool) void { +extern fn c_ret_vector_2_bool() @Vector(2, bool); +extern fn c_vector_2_bool(@Vector(2, bool)) void; +extern fn c_test_vector_2_bool() void; + +test "@Vector(2, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const vec = c_ret_vector_2_bool(); + try expect(vec[0] == true); + try expect(vec[1] == false); + c_vector_2_bool(.{ + true, + true, + }); + c_test_vector_2_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_4_bool() @Vector(4, bool) { + return .{ + false, + true, + true, + true, + }; + } + export fn zig_vector_4_bool(vec: @Vector(4, bool)) void { expect(vec[0] == false) catch @panic("test failure"); expect(vec[1] == false) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); expect(vec[3] == false) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_8_bool(vec: Vector8Bool) void { +extern fn c_ret_vector_4_bool() @Vector(4, bool); +extern fn c_vector_4_bool(@Vector(4, bool)) void; +extern fn c_test_vector_4_bool() void; + +test "@Vector(4, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const vec = c_ret_vector_4_bool(); + try expect(vec[0] == true); + try expect(vec[1] == false); + try expect(vec[2] == true); + try expect(vec[3] == false); + c_vector_4_bool(.{ + true, + true, + false, + true, + }); + c_test_vector_4_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_8_bool() @Vector(8, bool) { + return .{ + false, + false, + false, + false, + true, + false, + false, + false, + }; + } + export fn zig_vector_8_bool(vec: @Vector(8, bool)) void { expect(vec[0] == true) catch @panic("test failure"); expect(vec[1] == true) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); @@ -3580,8 +381,67 @@ comptime { expect(vec[6] == true) catch @panic("test failure"); expect(vec[7] == false) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_16_bool(vec: Vector16Bool) void { +extern fn c_ret_vector_8_bool() @Vector(8, bool); +extern fn c_vector_8_bool(@Vector(8, bool)) void; +extern fn c_test_vector_8_bool() void; + +test "@Vector(8, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const vec = c_ret_vector_8_bool(); + try expect(vec[0] == false); + try expect(vec[1] == true); + try expect(vec[2] == false); + try expect(vec[3] == false); + try expect(vec[4] == true); + try expect(vec[5] == false); + try expect(vec[6] == false); + try expect(vec[7] == true); + c_vector_8_bool(.{ + true, + false, + true, + true, + true, + true, + false, + true, + }); + c_test_vector_8_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_16_bool() @Vector(16, bool) { + return .{ + false, + true, + false, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + true, + false, + false, + }; + } + export fn zig_vector_16_bool(vec: @Vector(16, bool)) void { expect(vec[0] == true) catch @panic("test failure"); expect(vec[1] == false) catch @panic("test failure"); expect(vec[2] == true) catch @panic("test failure"); @@ -3599,8 +459,99 @@ comptime { expect(vec[14] == false) catch @panic("test failure"); expect(vec[15] == true) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_32_bool(vec: Vector32Bool) void { +extern fn c_ret_vector_16_bool() @Vector(16, bool); +extern fn c_vector_16_bool(@Vector(16, bool)) void; +extern fn c_test_vector_16_bool() void; + +test "@Vector(16, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const vec = c_ret_vector_16_bool(); + try expect(vec[0] == true); + try expect(vec[1] == true); + try expect(vec[2] == false); + try expect(vec[3] == false); + try expect(vec[4] == false); + try expect(vec[5] == false); + try expect(vec[6] == true); + try expect(vec[7] == false); + try expect(vec[8] == true); + try expect(vec[9] == false); + try expect(vec[10] == false); + try expect(vec[11] == true); + try expect(vec[12] == true); + try expect(vec[13] == false); + try expect(vec[14] == true); + try expect(vec[15] == true); + c_vector_16_bool(.{ + true, + false, + false, + false, + true, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + false, + }); + c_test_vector_16_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_32_bool() @Vector(32, bool) { + return .{ + false, + true, + false, + false, + true, + false, + true, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + }; + } + export fn zig_vector_32_bool(vec: @Vector(32, bool)) void { expect(vec[0] == false) catch @panic("test failure"); expect(vec[1] == false) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); @@ -3634,8 +585,163 @@ comptime { expect(vec[30] == false) catch @panic("test failure"); expect(vec[31] == true) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_64_bool(vec: Vector64Bool) void { +extern fn c_ret_vector_32_bool() @Vector(32, bool); +extern fn c_vector_32_bool(@Vector(32, bool)) void; +extern fn c_test_vector_32_bool() void; + +test "@Vector(32, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows and builtin.cpu.has(.x86, .avx)) return error.SkipZigTest; + + const vec = c_ret_vector_32_bool(); + try expect(vec[0] == true); + try expect(vec[1] == false); + try expect(vec[2] == true); + try expect(vec[3] == true); + try expect(vec[4] == true); + try expect(vec[5] == false); + try expect(vec[6] == true); + try expect(vec[7] == false); + try expect(vec[8] == true); + try expect(vec[9] == true); + try expect(vec[10] == true); + try expect(vec[11] == false); + try expect(vec[12] == true); + try expect(vec[13] == true); + try expect(vec[14] == false); + try expect(vec[15] == false); + try expect(vec[16] == true); + try expect(vec[17] == false); + try expect(vec[18] == false); + try expect(vec[19] == false); + try expect(vec[20] == false); + try expect(vec[21] == true); + try expect(vec[22] == true); + try expect(vec[23] == true); + try expect(vec[24] == false); + try expect(vec[25] == true); + try expect(vec[26] == false); + try expect(vec[27] == false); + try expect(vec[28] == true); + try expect(vec[29] == false); + try expect(vec[30] == false); + try expect(vec[31] == false); + c_vector_32_bool(.{ + true, + false, + true, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + }); + c_test_vector_32_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_64_bool() @Vector(64, bool) { + return .{ + true, + false, + true, + false, + false, + true, + false, + true, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + false, + true, + true, + true, + false, + true, + true, + true, + false, + false, + false, + true, + false, + false, + true, + false, + true, + false, + }; + } + export fn zig_vector_64_bool(vec: @Vector(64, bool)) void { expect(vec[0] == true) catch @panic("test failure"); expect(vec[1] == true) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); @@ -3701,8 +807,290 @@ comptime { expect(vec[62] == true) catch @panic("test failure"); expect(vec[63] == true) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_128_bool(vec: Vector128Bool) void { +extern fn c_ret_vector_64_bool() @Vector(64, bool); +extern fn c_vector_64_bool(@Vector(64, bool)) void; +extern fn c_test_vector_64_bool() void; + +test "@Vector(64, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + + const vec = c_ret_vector_64_bool(); + try expect(vec[0] == false); + try expect(vec[1] == true); + try expect(vec[2] == false); + try expect(vec[3] == true); + try expect(vec[4] == true); + try expect(vec[5] == true); + try expect(vec[6] == false); + try expect(vec[7] == true); + try expect(vec[8] == true); + try expect(vec[9] == true); + try expect(vec[10] == true); + try expect(vec[11] == true); + try expect(vec[12] == true); + try expect(vec[13] == false); + try expect(vec[14] == true); + try expect(vec[15] == true); + try expect(vec[16] == true); + try expect(vec[17] == false); + try expect(vec[18] == false); + try expect(vec[19] == false); + try expect(vec[20] == true); + try expect(vec[21] == true); + try expect(vec[22] == false); + try expect(vec[23] == true); + try expect(vec[24] == false); + try expect(vec[25] == true); + try expect(vec[26] == false); + try expect(vec[27] == true); + try expect(vec[28] == false); + try expect(vec[29] == true); + try expect(vec[30] == false); + try expect(vec[31] == true); + try expect(vec[32] == false); + try expect(vec[33] == false); + try expect(vec[34] == true); + try expect(vec[35] == true); + try expect(vec[36] == false); + try expect(vec[37] == false); + try expect(vec[38] == false); + try expect(vec[39] == true); + try expect(vec[40] == true); + try expect(vec[41] == true); + try expect(vec[42] == true); + try expect(vec[43] == false); + try expect(vec[44] == false); + try expect(vec[45] == false); + try expect(vec[46] == true); + try expect(vec[47] == true); + try expect(vec[48] == false); + try expect(vec[49] == false); + try expect(vec[50] == true); + try expect(vec[51] == false); + try expect(vec[52] == false); + try expect(vec[53] == false); + try expect(vec[54] == false); + try expect(vec[55] == true); + try expect(vec[56] == false); + try expect(vec[57] == false); + try expect(vec[58] == false); + try expect(vec[59] == true); + try expect(vec[60] == true); + try expect(vec[61] == true); + try expect(vec[62] == true); + try expect(vec[63] == true); + c_vector_64_bool(.{ + true, + true, + true, + false, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + true, + false, + true, + false, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + false, + true, + false, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + false, + }); + c_test_vector_64_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_128_bool() @Vector(128, bool) { + return .{ + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + false, + true, + false, + false, + true, + }; + } + export fn zig_vector_128_bool(vec: @Vector(128, bool)) void { expect(vec[0] == true) catch @panic("test failure"); expect(vec[1] == true) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); @@ -3832,8 +1220,546 @@ comptime { expect(vec[126] == true) catch @panic("test failure"); expect(vec[127] == false) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_256_bool(vec: Vector256Bool) void { +extern fn c_ret_vector_128_bool() @Vector(128, bool); +extern fn c_vector_128_bool(@Vector(128, bool)) void; +extern fn c_test_vector_128_bool() void; + +test "@Vector(128, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + + const vec = c_ret_vector_128_bool(); + try expect(vec[0] == false); + try expect(vec[1] == true); + try expect(vec[2] == true); + try expect(vec[3] == false); + try expect(vec[4] == true); + try expect(vec[5] == false); + try expect(vec[6] == false); + try expect(vec[7] == true); + try expect(vec[8] == true); + try expect(vec[9] == false); + try expect(vec[10] == true); + try expect(vec[11] == false); + try expect(vec[12] == false); + try expect(vec[13] == false); + try expect(vec[14] == true); + try expect(vec[15] == false); + try expect(vec[16] == true); + try expect(vec[17] == false); + try expect(vec[18] == false); + try expect(vec[19] == true); + try expect(vec[20] == false); + try expect(vec[21] == true); + try expect(vec[22] == false); + try expect(vec[23] == false); + try expect(vec[24] == false); + try expect(vec[25] == true); + try expect(vec[26] == true); + try expect(vec[27] == true); + try expect(vec[28] == false); + try expect(vec[29] == false); + try expect(vec[30] == false); + try expect(vec[31] == false); + try expect(vec[32] == true); + try expect(vec[33] == true); + try expect(vec[34] == true); + try expect(vec[35] == false); + try expect(vec[36] == true); + try expect(vec[37] == true); + try expect(vec[38] == false); + try expect(vec[39] == false); + try expect(vec[40] == false); + try expect(vec[41] == false); + try expect(vec[42] == true); + try expect(vec[43] == true); + try expect(vec[44] == true); + try expect(vec[45] == false); + try expect(vec[46] == false); + try expect(vec[47] == false); + try expect(vec[48] == false); + try expect(vec[49] == true); + try expect(vec[50] == false); + try expect(vec[51] == false); + try expect(vec[52] == true); + try expect(vec[53] == false); + try expect(vec[54] == false); + try expect(vec[55] == false); + try expect(vec[56] == false); + try expect(vec[57] == false); + try expect(vec[58] == true); + try expect(vec[59] == true); + try expect(vec[60] == true); + try expect(vec[61] == false); + try expect(vec[62] == true); + try expect(vec[63] == true); + try expect(vec[64] == false); + try expect(vec[65] == false); + try expect(vec[66] == false); + try expect(vec[67] == false); + try expect(vec[68] == false); + try expect(vec[69] == false); + try expect(vec[70] == false); + try expect(vec[71] == false); + try expect(vec[72] == true); + try expect(vec[73] == true); + try expect(vec[74] == true); + try expect(vec[75] == true); + try expect(vec[76] == true); + try expect(vec[77] == false); + try expect(vec[78] == false); + try expect(vec[79] == false); + try expect(vec[80] == false); + try expect(vec[81] == false); + try expect(vec[82] == false); + try expect(vec[83] == true); + try expect(vec[84] == false); + try expect(vec[85] == true); + try expect(vec[86] == false); + try expect(vec[87] == true); + try expect(vec[88] == false); + try expect(vec[89] == true); + try expect(vec[90] == false); + try expect(vec[91] == true); + try expect(vec[92] == true); + try expect(vec[93] == true); + try expect(vec[94] == true); + try expect(vec[95] == false); + try expect(vec[96] == false); + try expect(vec[97] == true); + try expect(vec[98] == false); + try expect(vec[99] == false); + try expect(vec[100] == true); + try expect(vec[101] == true); + try expect(vec[102] == true); + try expect(vec[103] == true); + try expect(vec[104] == false); + try expect(vec[105] == true); + try expect(vec[106] == true); + try expect(vec[107] == true); + try expect(vec[108] == false); + try expect(vec[109] == false); + try expect(vec[110] == true); + try expect(vec[111] == false); + try expect(vec[112] == false); + try expect(vec[113] == true); + try expect(vec[114] == true); + try expect(vec[115] == false); + try expect(vec[116] == true); + try expect(vec[117] == false); + try expect(vec[118] == true); + try expect(vec[119] == true); + try expect(vec[120] == true); + try expect(vec[121] == true); + try expect(vec[122] == true); + try expect(vec[123] == false); + try expect(vec[124] == false); + try expect(vec[125] == true); + try expect(vec[126] == false); + try expect(vec[127] == true); + c_vector_128_bool(.{ + false, + false, + false, + false, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + true, + false, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + true, + false, + true, + false, + false, + false, + false, + true, + false, + false, + false, + true, + true, + false, + false, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + }); + c_test_vector_128_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_256_bool() @Vector(256, bool) { + return .{ + true, + true, + true, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + false, + false, + true, + false, + true, + false, + false, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + true, + false, + true, + true, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + false, + true, + true, + false, + true, + false, + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + false, + true, + true, + false, + true, + false, + true, + true, + false, + false, + false, + false, + false, + false, + false, + true, + true, + true, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + true, + true, + true, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + true, + false, + false, + false, + true, + true, + true, + false, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + }; + } + export fn zig_vector_256_bool(vec: @Vector(256, bool)) void { expect(vec[0] == false) catch @panic("test failure"); expect(vec[1] == false) catch @panic("test failure"); expect(vec[2] == false) catch @panic("test failure"); @@ -4091,8 +2017,1058 @@ comptime { expect(vec[254] == true) catch @panic("test failure"); expect(vec[255] == true) catch @panic("test failure"); } + }; + } +} - export fn zig_vector_512_bool(vec: Vector512Bool) void { +extern fn c_ret_vector_256_bool() @Vector(256, bool); +extern fn c_vector_256_bool(@Vector(256, bool)) void; +extern fn c_test_vector_256_bool() void; + +test "@Vector(256, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; + + const vec = c_ret_vector_256_bool(); + try expect(vec[0] == true); + try expect(vec[1] == false); + try expect(vec[2] == true); + try expect(vec[3] == true); + try expect(vec[4] == false); + try expect(vec[5] == false); + try expect(vec[6] == false); + try expect(vec[7] == false); + try expect(vec[8] == false); + try expect(vec[9] == true); + try expect(vec[10] == false); + try expect(vec[11] == true); + try expect(vec[12] == false); + try expect(vec[13] == true); + try expect(vec[14] == false); + try expect(vec[15] == false); + try expect(vec[16] == true); + try expect(vec[17] == true); + try expect(vec[18] == true); + try expect(vec[19] == false); + try expect(vec[20] == false); + try expect(vec[21] == false); + try expect(vec[22] == true); + try expect(vec[23] == false); + try expect(vec[24] == true); + try expect(vec[25] == false); + try expect(vec[26] == false); + try expect(vec[27] == true); + try expect(vec[28] == true); + try expect(vec[29] == true); + try expect(vec[30] == false); + try expect(vec[31] == false); + try expect(vec[32] == true); + try expect(vec[33] == true); + try expect(vec[34] == true); + try expect(vec[35] == false); + try expect(vec[36] == true); + try expect(vec[37] == true); + try expect(vec[38] == true); + try expect(vec[39] == false); + try expect(vec[40] == true); + try expect(vec[41] == false); + try expect(vec[42] == true); + try expect(vec[43] == true); + try expect(vec[44] == false); + try expect(vec[45] == true); + try expect(vec[46] == false); + try expect(vec[47] == true); + try expect(vec[48] == true); + try expect(vec[49] == false); + try expect(vec[50] == false); + try expect(vec[51] == true); + try expect(vec[52] == true); + try expect(vec[53] == false); + try expect(vec[54] == false); + try expect(vec[55] == true); + try expect(vec[56] == false); + try expect(vec[57] == true); + try expect(vec[58] == true); + try expect(vec[59] == true); + try expect(vec[60] == false); + try expect(vec[61] == true); + try expect(vec[62] == true); + try expect(vec[63] == false); + try expect(vec[64] == true); + try expect(vec[65] == true); + try expect(vec[66] == false); + try expect(vec[67] == true); + try expect(vec[68] == false); + try expect(vec[69] == true); + try expect(vec[70] == true); + try expect(vec[71] == true); + try expect(vec[72] == false); + try expect(vec[73] == true); + try expect(vec[74] == true); + try expect(vec[75] == false); + try expect(vec[76] == true); + try expect(vec[77] == true); + try expect(vec[78] == true); + try expect(vec[79] == true); + try expect(vec[80] == false); + try expect(vec[81] == true); + try expect(vec[82] == false); + try expect(vec[83] == true); + try expect(vec[84] == true); + try expect(vec[85] == true); + try expect(vec[86] == false); + try expect(vec[87] == true); + try expect(vec[88] == false); + try expect(vec[89] == true); + try expect(vec[90] == false); + try expect(vec[91] == false); + try expect(vec[92] == true); + try expect(vec[93] == false); + try expect(vec[94] == false); + try expect(vec[95] == false); + try expect(vec[96] == true); + try expect(vec[97] == true); + try expect(vec[98] == false); + try expect(vec[99] == false); + try expect(vec[100] == false); + try expect(vec[101] == true); + try expect(vec[102] == true); + try expect(vec[103] == true); + try expect(vec[104] == false); + try expect(vec[105] == false); + try expect(vec[106] == false); + try expect(vec[107] == true); + try expect(vec[108] == false); + try expect(vec[109] == true); + try expect(vec[110] == true); + try expect(vec[111] == true); + try expect(vec[112] == true); + try expect(vec[113] == true); + try expect(vec[114] == true); + try expect(vec[115] == true); + try expect(vec[116] == true); + try expect(vec[117] == false); + try expect(vec[118] == true); + try expect(vec[119] == false); + try expect(vec[120] == true); + try expect(vec[121] == false); + try expect(vec[122] == false); + try expect(vec[123] == true); + try expect(vec[124] == true); + try expect(vec[125] == false); + try expect(vec[126] == true); + try expect(vec[127] == false); + try expect(vec[128] == false); + try expect(vec[129] == false); + try expect(vec[130] == false); + try expect(vec[131] == true); + try expect(vec[132] == false); + try expect(vec[133] == false); + try expect(vec[134] == true); + try expect(vec[135] == false); + try expect(vec[136] == false); + try expect(vec[137] == false); + try expect(vec[138] == false); + try expect(vec[139] == false); + try expect(vec[140] == false); + try expect(vec[141] == true); + try expect(vec[142] == false); + try expect(vec[143] == true); + try expect(vec[144] == false); + try expect(vec[145] == true); + try expect(vec[146] == true); + try expect(vec[147] == true); + try expect(vec[148] == false); + try expect(vec[149] == true); + try expect(vec[150] == true); + try expect(vec[151] == false); + try expect(vec[152] == true); + try expect(vec[153] == true); + try expect(vec[154] == false); + try expect(vec[155] == true); + try expect(vec[156] == true); + try expect(vec[157] == true); + try expect(vec[158] == true); + try expect(vec[159] == true); + try expect(vec[160] == true); + try expect(vec[161] == true); + try expect(vec[162] == false); + try expect(vec[163] == false); + try expect(vec[164] == false); + try expect(vec[165] == true); + try expect(vec[166] == false); + try expect(vec[167] == false); + try expect(vec[168] == true); + try expect(vec[169] == false); + try expect(vec[170] == true); + try expect(vec[171] == true); + try expect(vec[172] == true); + try expect(vec[173] == false); + try expect(vec[174] == false); + try expect(vec[175] == true); + try expect(vec[176] == true); + try expect(vec[177] == true); + try expect(vec[178] == true); + try expect(vec[179] == false); + try expect(vec[180] == true); + try expect(vec[181] == true); + try expect(vec[182] == false); + try expect(vec[183] == true); + try expect(vec[184] == false); + try expect(vec[185] == false); + try expect(vec[186] == false); + try expect(vec[187] == true); + try expect(vec[188] == true); + try expect(vec[189] == true); + try expect(vec[190] == true); + try expect(vec[191] == true); + try expect(vec[192] == true); + try expect(vec[193] == true); + try expect(vec[194] == true); + try expect(vec[195] == false); + try expect(vec[196] == false); + try expect(vec[197] == true); + try expect(vec[198] == false); + try expect(vec[199] == false); + try expect(vec[200] == false); + try expect(vec[201] == true); + try expect(vec[202] == true); + try expect(vec[203] == true); + try expect(vec[204] == true); + try expect(vec[205] == true); + try expect(vec[206] == true); + try expect(vec[207] == false); + try expect(vec[208] == false); + try expect(vec[209] == false); + try expect(vec[210] == true); + try expect(vec[211] == true); + try expect(vec[212] == true); + try expect(vec[213] == false); + try expect(vec[214] == true); + try expect(vec[215] == false); + try expect(vec[216] == true); + try expect(vec[217] == false); + try expect(vec[218] == true); + try expect(vec[219] == false); + try expect(vec[220] == true); + try expect(vec[221] == true); + try expect(vec[222] == true); + try expect(vec[223] == false); + try expect(vec[224] == true); + try expect(vec[225] == false); + try expect(vec[226] == true); + try expect(vec[227] == false); + try expect(vec[228] == true); + try expect(vec[229] == false); + try expect(vec[230] == true); + try expect(vec[231] == false); + try expect(vec[232] == false); + try expect(vec[233] == true); + try expect(vec[234] == false); + try expect(vec[235] == true); + try expect(vec[236] == true); + try expect(vec[237] == false); + try expect(vec[238] == false); + try expect(vec[239] == true); + try expect(vec[240] == false); + try expect(vec[241] == false); + try expect(vec[242] == false); + try expect(vec[243] == true); + try expect(vec[244] == true); + try expect(vec[245] == false); + try expect(vec[246] == false); + try expect(vec[247] == false); + try expect(vec[248] == false); + try expect(vec[249] == false); + try expect(vec[250] == true); + try expect(vec[251] == false); + try expect(vec[252] == true); + try expect(vec[253] == false); + try expect(vec[254] == false); + try expect(vec[255] == false); + if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{ + false, + true, + true, + false, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + false, + false, + false, + true, + true, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + false, + true, + true, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + false, + false, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + true, + false, + true, + true, + true, + false, + }); + c_test_vector_512_bool(); +} + +comptime { + skip: { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip; + + _ = struct { + export fn zig_ret_vector_512_bool() @Vector(512, bool) { + return .{ + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + true, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + true, + false, + false, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + true, + true, + true, + true, + false, + true, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + false, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + false, + true, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + false, + true, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + true, + false, + true, + false, + false, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + false, + true, + true, + false, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + false, + true, + true, + true, + true, + false, + false, + true, + true, + false, + false, + }; + } + export fn zig_vector_512_bool(vec: @Vector(512, bool)) void { expect(vec[0] == false) catch @panic("test failure"); expect(vec[1] == true) catch @panic("test failure"); expect(vec[2] == true) catch @panic("test failure"); @@ -4606,1095 +3582,13098 @@ comptime { expect(vec[510] == false) catch @panic("test failure"); expect(vec[511] == true) catch @panic("test failure"); } - - export fn zig_ret_vector_2_bool() Vector2Bool { - return .{ - false, - false, - }; - } - - export fn zig_ret_vector_4_bool() Vector4Bool { - return .{ - false, - true, - true, - true, - }; - } - - export fn zig_ret_vector_8_bool() Vector8Bool { - return .{ - false, - false, - false, - false, - true, - false, - false, - false, - }; - } - - export fn zig_ret_vector_16_bool() Vector16Bool { - return .{ - false, - true, - false, - false, - false, - true, - false, - false, - true, - false, - false, - false, - false, - true, - false, - false, - }; - } - - export fn zig_ret_vector_32_bool() Vector32Bool { - return .{ - false, - true, - false, - false, - true, - false, - true, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - }; - } - - export fn zig_ret_vector_64_bool() Vector64Bool { - return .{ - true, - false, - true, - false, - false, - true, - false, - true, - true, - false, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - false, - false, - false, - true, - true, - true, - false, - true, - true, - true, - false, - false, - false, - true, - false, - false, - true, - false, - true, - false, - }; - } - - export fn zig_ret_vector_128_bool() Vector128Bool { - return .{ - true, - true, - false, - false, - false, - true, - true, - false, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - false, - false, - false, - true, - false, - true, - false, - true, - false, - false, - true, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - true, - false, - true, - false, - false, - true, - true, - false, - true, - false, - false, - true, - true, - true, - true, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - false, - true, - false, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - true, - false, - false, - true, - }; - } - - export fn zig_ret_vector_256_bool() Vector256Bool { - return .{ - true, - true, - true, - false, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - false, - false, - true, - false, - true, - false, - false, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - false, - true, - false, - true, - false, - true, - false, - true, - false, - false, - false, - true, - true, - true, - false, - false, - false, - true, - false, - true, - false, - true, - false, - true, - true, - false, - false, - false, - true, - true, - true, - false, - true, - false, - true, - false, - true, - true, - false, - true, - false, - true, - true, - false, - false, - false, - false, - false, - false, - false, - false, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - false, - true, - true, - false, - false, - true, - false, - false, - false, - false, - false, - false, - false, - true, - true, - false, - true, - false, - true, - true, - false, - false, - false, - false, - false, - false, - false, - true, - true, - true, - false, - true, - true, - false, - false, - true, - true, - true, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - false, - true, - false, - true, - true, - true, - true, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - true, - true, - true, - true, - true, - false, - false, - true, - false, - true, - true, - true, - true, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - true, - true, - true, - true, - true, - true, - false, - true, - false, - false, - true, - true, - false, - false, - false, - true, - true, - true, - false, - false, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - }; - } - - export fn zig_ret_vector_512_bool() Vector512Bool { - return .{ - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - true, - true, - false, - false, - false, - false, - true, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - true, - false, - false, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - false, - false, - false, - true, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - false, - false, - true, - false, - true, - false, - true, - false, - false, - true, - true, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - true, - false, - false, - false, - true, - false, - true, - false, - false, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - false, - true, - false, - true, - true, - true, - true, - false, - true, - false, - false, - true, - true, - true, - false, - false, - false, - true, - false, - false, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - false, - false, - true, - true, - true, - false, - false, - true, - true, - true, - false, - false, - true, - false, - true, - true, - false, - true, - false, - false, - true, - false, - false, - true, - true, - false, - true, - true, - true, - true, - true, - false, - true, - false, - false, - true, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - false, - false, - false, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - false, - true, - false, - true, - true, - true, - true, - true, - true, - false, - false, - true, - true, - false, - false, - false, - false, - true, - true, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - true, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - true, - false, - true, - true, - true, - false, - false, - false, - true, - true, - false, - true, - false, - true, - false, - false, - true, - false, - true, - false, - false, - false, - false, - false, - true, - true, - false, - false, - false, - false, - true, - false, - true, - false, - true, - true, - false, - true, - true, - true, - true, - true, - false, - true, - false, - true, - true, - true, - true, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - true, - false, - false, - true, - false, - true, - false, - false, - true, - false, - true, - true, - false, - true, - false, - true, - false, - true, - false, - false, - true, - true, - false, - true, - true, - false, - true, - true, - false, - false, - false, - false, - false, - true, - false, - false, - true, - false, - true, - false, - false, - false, - true, - false, - true, - false, - false, - false, - false, - true, - true, - false, - true, - true, - false, - false, - true, - true, - true, - false, - false, - true, - false, - false, - false, - true, - true, - false, - false, - false, - false, - false, - true, - true, - true, - true, - false, - false, - false, - true, - false, - true, - true, - true, - true, - false, - false, - true, - true, - false, - false, - }; - } }; } } -const Vector2 = extern struct { x: f32, y: f32 }; +extern fn c_ret_vector_512_bool() @Vector(512, bool); +extern fn c_vector_512_bool(@Vector(512, bool)) void; +extern fn c_test_vector_512_bool() void; -extern fn c_ptr_size_float_struct(Vector2) void; -extern fn c_ret_ptr_size_float_struct() Vector2; +test "@Vector(512, bool)" { + if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; -test "C ABI pointer sized float struct" { + const vec = c_ret_vector_512_bool(); + try expect(vec[0] == false); + try expect(vec[1] == true); + try expect(vec[2] == false); + try expect(vec[3] == false); + try expect(vec[4] == false); + try expect(vec[5] == true); + try expect(vec[6] == false); + try expect(vec[7] == false); + try expect(vec[8] == false); + try expect(vec[9] == true); + try expect(vec[10] == false); + try expect(vec[11] == false); + try expect(vec[12] == false); + try expect(vec[13] == true); + try expect(vec[14] == false); + try expect(vec[15] == true); + try expect(vec[16] == false); + try expect(vec[17] == false); + try expect(vec[18] == false); + try expect(vec[19] == false); + try expect(vec[20] == false); + try expect(vec[21] == false); + try expect(vec[22] == true); + try expect(vec[23] == true); + try expect(vec[24] == false); + try expect(vec[25] == false); + try expect(vec[26] == false); + try expect(vec[27] == false); + try expect(vec[28] == true); + try expect(vec[29] == true); + try expect(vec[30] == false); + try expect(vec[31] == true); + try expect(vec[32] == false); + try expect(vec[33] == true); + try expect(vec[34] == true); + try expect(vec[35] == true); + try expect(vec[36] == false); + try expect(vec[37] == false); + try expect(vec[38] == true); + try expect(vec[39] == true); + try expect(vec[40] == false); + try expect(vec[41] == false); + try expect(vec[42] == false); + try expect(vec[43] == false); + try expect(vec[44] == false); + try expect(vec[45] == true); + try expect(vec[46] == false); + try expect(vec[47] == true); + try expect(vec[48] == true); + try expect(vec[49] == false); + try expect(vec[50] == true); + try expect(vec[51] == true); + try expect(vec[52] == true); + try expect(vec[53] == true); + try expect(vec[54] == false); + try expect(vec[55] == false); + try expect(vec[56] == false); + try expect(vec[57] == true); + try expect(vec[58] == true); + try expect(vec[59] == false); + try expect(vec[60] == false); + try expect(vec[61] == false); + try expect(vec[62] == false); + try expect(vec[63] == true); + try expect(vec[64] == true); + try expect(vec[65] == true); + try expect(vec[66] == true); + try expect(vec[67] == true); + try expect(vec[68] == false); + try expect(vec[69] == false); + try expect(vec[70] == false); + try expect(vec[71] == false); + try expect(vec[72] == false); + try expect(vec[73] == true); + try expect(vec[74] == false); + try expect(vec[75] == true); + try expect(vec[76] == false); + try expect(vec[77] == false); + try expect(vec[78] == true); + try expect(vec[79] == true); + try expect(vec[80] == false); + try expect(vec[81] == false); + try expect(vec[82] == false); + try expect(vec[83] == true); + try expect(vec[84] == false); + try expect(vec[85] == true); + try expect(vec[86] == true); + try expect(vec[87] == true); + try expect(vec[88] == false); + try expect(vec[89] == true); + try expect(vec[90] == false); + try expect(vec[91] == false); + try expect(vec[92] == true); + try expect(vec[93] == true); + try expect(vec[94] == false); + try expect(vec[95] == true); + try expect(vec[96] == true); + try expect(vec[97] == false); + try expect(vec[98] == true); + try expect(vec[99] == false); + try expect(vec[100] == true); + try expect(vec[101] == true); + try expect(vec[102] == false); + try expect(vec[103] == true); + try expect(vec[104] == true); + try expect(vec[105] == false); + try expect(vec[106] == false); + try expect(vec[107] == false); + try expect(vec[108] == true); + try expect(vec[109] == false); + try expect(vec[110] == false); + try expect(vec[111] == false); + try expect(vec[112] == true); + try expect(vec[113] == true); + try expect(vec[114] == true); + try expect(vec[115] == false); + try expect(vec[116] == true); + try expect(vec[117] == false); + try expect(vec[118] == true); + try expect(vec[119] == false); + try expect(vec[120] == true); + try expect(vec[121] == true); + try expect(vec[122] == false); + try expect(vec[123] == true); + try expect(vec[124] == false); + try expect(vec[125] == true); + try expect(vec[126] == true); + try expect(vec[127] == true); + try expect(vec[128] == false); + try expect(vec[129] == true); + try expect(vec[130] == false); + try expect(vec[131] == false); + try expect(vec[132] == false); + try expect(vec[133] == false); + try expect(vec[134] == false); + try expect(vec[135] == false); + try expect(vec[136] == true); + try expect(vec[137] == false); + try expect(vec[138] == true); + try expect(vec[139] == false); + try expect(vec[140] == true); + try expect(vec[141] == true); + try expect(vec[142] == false); + try expect(vec[143] == true); + try expect(vec[144] == false); + try expect(vec[145] == false); + try expect(vec[146] == true); + try expect(vec[147] == false); + try expect(vec[148] == false); + try expect(vec[149] == true); + try expect(vec[150] == false); + try expect(vec[151] == true); + try expect(vec[152] == false); + try expect(vec[153] == true); + try expect(vec[154] == false); + try expect(vec[155] == false); + try expect(vec[156] == true); + try expect(vec[157] == false); + try expect(vec[158] == true); + try expect(vec[159] == true); + try expect(vec[160] == true); + try expect(vec[161] == false); + try expect(vec[162] == false); + try expect(vec[163] == true); + try expect(vec[164] == false); + try expect(vec[165] == false); + try expect(vec[166] == false); + try expect(vec[167] == true); + try expect(vec[168] == true); + try expect(vec[169] == true); + try expect(vec[170] == false); + try expect(vec[171] == true); + try expect(vec[172] == false); + try expect(vec[173] == false); + try expect(vec[174] == false); + try expect(vec[175] == false); + try expect(vec[176] == false); + try expect(vec[177] == true); + try expect(vec[178] == true); + try expect(vec[179] == false); + try expect(vec[180] == false); + try expect(vec[181] == true); + try expect(vec[182] == false); + try expect(vec[183] == false); + try expect(vec[184] == false); + try expect(vec[185] == false); + try expect(vec[186] == false); + try expect(vec[187] == true); + try expect(vec[188] == true); + try expect(vec[189] == false); + try expect(vec[190] == false); + try expect(vec[191] == false); + try expect(vec[192] == false); + try expect(vec[193] == false); + try expect(vec[194] == false); + try expect(vec[195] == true); + try expect(vec[196] == true); + try expect(vec[197] == false); + try expect(vec[198] == true); + try expect(vec[199] == true); + try expect(vec[200] == true); + try expect(vec[201] == true); + try expect(vec[202] == true); + try expect(vec[203] == true); + try expect(vec[204] == false); + try expect(vec[205] == false); + try expect(vec[206] == false); + try expect(vec[207] == false); + try expect(vec[208] == true); + try expect(vec[209] == false); + try expect(vec[210] == true); + try expect(vec[211] == true); + try expect(vec[212] == true); + try expect(vec[213] == true); + try expect(vec[214] == false); + try expect(vec[215] == false); + try expect(vec[216] == false); + try expect(vec[217] == true); + try expect(vec[218] == true); + try expect(vec[219] == false); + try expect(vec[220] == true); + try expect(vec[221] == true); + try expect(vec[222] == false); + try expect(vec[223] == false); + try expect(vec[224] == false); + try expect(vec[225] == true); + try expect(vec[226] == true); + try expect(vec[227] == true); + try expect(vec[228] == true); + try expect(vec[229] == false); + try expect(vec[230] == true); + try expect(vec[231] == false); + try expect(vec[232] == true); + try expect(vec[233] == true); + try expect(vec[234] == true); + try expect(vec[235] == true); + try expect(vec[236] == false); + try expect(vec[237] == true); + try expect(vec[238] == false); + try expect(vec[239] == true); + try expect(vec[240] == false); + try expect(vec[241] == true); + try expect(vec[242] == false); + try expect(vec[243] == false); + try expect(vec[244] == false); + try expect(vec[245] == true); + try expect(vec[246] == true); + try expect(vec[247] == false); + try expect(vec[248] == true); + try expect(vec[249] == false); + try expect(vec[250] == false); + try expect(vec[251] == false); + try expect(vec[252] == true); + try expect(vec[253] == true); + try expect(vec[254] == true); + try expect(vec[255] == true); + try expect(vec[256] == true); + try expect(vec[257] == false); + try expect(vec[258] == true); + try expect(vec[259] == true); + try expect(vec[260] == true); + try expect(vec[261] == true); + try expect(vec[262] == false); + try expect(vec[263] == true); + try expect(vec[264] == false); + try expect(vec[265] == false); + try expect(vec[266] == true); + try expect(vec[267] == false); + try expect(vec[268] == true); + try expect(vec[269] == false); + try expect(vec[270] == false); + try expect(vec[271] == true); + try expect(vec[272] == true); + try expect(vec[273] == false); + try expect(vec[274] == true); + try expect(vec[275] == false); + try expect(vec[276] == false); + try expect(vec[277] == true); + try expect(vec[278] == false); + try expect(vec[279] == false); + try expect(vec[280] == true); + try expect(vec[281] == true); + try expect(vec[282] == true); + try expect(vec[283] == false); + try expect(vec[284] == false); + try expect(vec[285] == true); + try expect(vec[286] == true); + try expect(vec[287] == true); + try expect(vec[288] == false); + try expect(vec[289] == false); + try expect(vec[290] == false); + try expect(vec[291] == false); + try expect(vec[292] == false); + try expect(vec[293] == false); + try expect(vec[294] == true); + try expect(vec[295] == false); + try expect(vec[296] == true); + try expect(vec[297] == false); + try expect(vec[298] == true); + try expect(vec[299] == true); + try expect(vec[300] == false); + try expect(vec[301] == false); + try expect(vec[302] == false); + try expect(vec[303] == false); + try expect(vec[304] == true); + try expect(vec[305] == true); + try expect(vec[306] == true); + try expect(vec[307] == true); + try expect(vec[308] == true); + try expect(vec[309] == false); + try expect(vec[310] == true); + try expect(vec[311] == true); + try expect(vec[312] == true); + try expect(vec[313] == true); + try expect(vec[314] == true); + try expect(vec[315] == false); + try expect(vec[316] == true); + try expect(vec[317] == true); + try expect(vec[318] == true); + try expect(vec[319] == false); + try expect(vec[320] == true); + try expect(vec[321] == false); + try expect(vec[322] == true); + try expect(vec[323] == true); + try expect(vec[324] == true); + try expect(vec[325] == false); + try expect(vec[326] == false); + try expect(vec[327] == true); + try expect(vec[328] == true); + try expect(vec[329] == true); + try expect(vec[330] == false); + try expect(vec[331] == false); + try expect(vec[332] == true); + try expect(vec[333] == true); + try expect(vec[334] == false); + try expect(vec[335] == true); + try expect(vec[336] == true); + try expect(vec[337] == true); + try expect(vec[338] == true); + try expect(vec[339] == true); + try expect(vec[340] == true); + try expect(vec[341] == false); + try expect(vec[342] == true); + try expect(vec[343] == false); + try expect(vec[344] == true); + try expect(vec[345] == false); + try expect(vec[346] == false); + try expect(vec[347] == false); + try expect(vec[348] == false); + try expect(vec[349] == true); + try expect(vec[350] == true); + try expect(vec[351] == true); + try expect(vec[352] == true); + try expect(vec[353] == false); + try expect(vec[354] == true); + try expect(vec[355] == false); + try expect(vec[356] == true); + try expect(vec[357] == true); + try expect(vec[358] == false); + try expect(vec[359] == true); + try expect(vec[360] == false); + try expect(vec[361] == false); + try expect(vec[362] == true); + try expect(vec[363] == false); + try expect(vec[364] == false); + try expect(vec[365] == false); + try expect(vec[366] == false); + try expect(vec[367] == false); + try expect(vec[368] == false); + try expect(vec[369] == false); + try expect(vec[370] == true); + try expect(vec[371] == false); + try expect(vec[372] == true); + try expect(vec[373] == true); + try expect(vec[374] == false); + try expect(vec[375] == false); + try expect(vec[376] == true); + try expect(vec[377] == false); + try expect(vec[378] == false); + try expect(vec[379] == true); + try expect(vec[380] == false); + try expect(vec[381] == false); + try expect(vec[382] == true); + try expect(vec[383] == false); + try expect(vec[384] == false); + try expect(vec[385] == false); + try expect(vec[386] == false); + try expect(vec[387] == true); + try expect(vec[388] == true); + try expect(vec[389] == true); + try expect(vec[390] == true); + try expect(vec[391] == true); + try expect(vec[392] == true); + try expect(vec[393] == true); + try expect(vec[394] == false); + try expect(vec[395] == true); + try expect(vec[396] == true); + try expect(vec[397] == false); + try expect(vec[398] == false); + try expect(vec[399] == false); + try expect(vec[400] == true); + try expect(vec[401] == false); + try expect(vec[402] == true); + try expect(vec[403] == true); + try expect(vec[404] == false); + try expect(vec[405] == true); + try expect(vec[406] == true); + try expect(vec[407] == true); + try expect(vec[408] == true); + try expect(vec[409] == false); + try expect(vec[410] == false); + try expect(vec[411] == false); + try expect(vec[412] == true); + try expect(vec[413] == true); + try expect(vec[414] == false); + try expect(vec[415] == true); + try expect(vec[416] == false); + try expect(vec[417] == true); + try expect(vec[418] == false); + try expect(vec[419] == false); + try expect(vec[420] == false); + try expect(vec[421] == false); + try expect(vec[422] == true); + try expect(vec[423] == true); + try expect(vec[424] == true); + try expect(vec[425] == false); + try expect(vec[426] == true); + try expect(vec[427] == false); + try expect(vec[428] == false); + try expect(vec[429] == false); + try expect(vec[430] == true); + try expect(vec[431] == true); + try expect(vec[432] == false); + try expect(vec[433] == true); + try expect(vec[434] == false); + try expect(vec[435] == false); + try expect(vec[436] == true); + try expect(vec[437] == true); + try expect(vec[438] == true); + try expect(vec[439] == true); + try expect(vec[440] == true); + try expect(vec[441] == true); + try expect(vec[442] == false); + try expect(vec[443] == false); + try expect(vec[444] == false); + try expect(vec[445] == true); + try expect(vec[446] == true); + try expect(vec[447] == true); + try expect(vec[448] == false); + try expect(vec[449] == false); + try expect(vec[450] == false); + try expect(vec[451] == false); + try expect(vec[452] == false); + try expect(vec[453] == false); + try expect(vec[454] == false); + try expect(vec[455] == false); + try expect(vec[456] == false); + try expect(vec[457] == false); + try expect(vec[458] == false); + try expect(vec[459] == true); + try expect(vec[460] == false); + try expect(vec[461] == false); + try expect(vec[462] == false); + try expect(vec[463] == true); + try expect(vec[464] == false); + try expect(vec[465] == false); + try expect(vec[466] == false); + try expect(vec[467] == false); + try expect(vec[468] == true); + try expect(vec[469] == true); + try expect(vec[470] == true); + try expect(vec[471] == true); + try expect(vec[472] == true); + try expect(vec[473] == false); + try expect(vec[474] == false); + try expect(vec[475] == true); + try expect(vec[476] == true); + try expect(vec[477] == true); + try expect(vec[478] == false); + try expect(vec[479] == true); + try expect(vec[480] == true); + try expect(vec[481] == true); + try expect(vec[482] == false); + try expect(vec[483] == true); + try expect(vec[484] == false); + try expect(vec[485] == true); + try expect(vec[486] == false); + try expect(vec[487] == true); + try expect(vec[488] == false); + try expect(vec[489] == true); + try expect(vec[490] == true); + try expect(vec[491] == true); + try expect(vec[492] == true); + try expect(vec[493] == false); + try expect(vec[494] == true); + try expect(vec[495] == true); + try expect(vec[496] == false); + try expect(vec[497] == true); + try expect(vec[498] == false); + try expect(vec[499] == false); + try expect(vec[500] == false); + try expect(vec[501] == false); + try expect(vec[502] == false); + try expect(vec[503] == false); + try expect(vec[504] == false); + try expect(vec[505] == false); + try expect(vec[506] == false); + try expect(vec[507] == true); + try expect(vec[508] == true); + try expect(vec[509] == false); + try expect(vec[510] == true); + try expect(vec[511] == false); + if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{ + true, + true, + true, + true, + true, + false, + false, + true, + true, + true, + true, + false, + true, + true, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + true, + false, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + true, + false, + false, + false, + true, + false, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + true, + false, + false, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + false, + true, + false, + false, + false, + false, + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + true, + true, + false, + true, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + true, + false, + true, + false, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + true, + false, + true, + false, + false, + false, + true, + false, + false, + true, + true, + false, + false, + false, + false, + false, + true, + false, + true, + true, + true, + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + false, + true, + false, + true, + true, + true, + false, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + true, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + false, + true, + true, + true, + true, + false, + false, + true, + false, + true, + false, + false, + false, + true, + false, + true, + false, + false, + true, + true, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + true, + false, + false, + true, + true, + true, + true, + false, + false, + true, + false, + true, + true, + false, + true, + true, + false, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + false, + true, + true, + true, + false, + false, + false, + false, + false, + true, + false, + false, + false, + false, + true, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + false, + true, + false, + true, + true, + true, + true, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + true, + true, + true, + true, + false, + false, + true, + false, + true, + false, + false, + true, + false, + false, + true, + true, + true, + true, + true, + true, + false, + true, + false, + false, + false, + true, + true, + false, + true, + true, + false, + false, + true, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + true, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + }); + c_test_vector_512_bool(); +} + +export fn zig_ret_vector_1_u8() @Vector(1, u8) { + return .{1}; +} +export fn zig_vector_1_u8(v: @Vector(1, u8), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_u8() @Vector(1, u8); +extern fn c_vector_1_u8(@Vector(1, u8), usize) void; +extern fn c_test_vector_1_u8() void; + +test "@Vector(1, u8)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + + const v = c_ret_vector_1_u8(); + try expect(v[0] == 3); + c_vector_1_u8(.{4}, 1); + c_test_vector_1_u8(); +} + +export fn zig_ret_vector_2_u8() @Vector(2, u8) { + return .{ 5, 6 }; +} +export fn zig_vector_2_u8(v: @Vector(2, u8), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_u8() @Vector(2, u8); +extern fn c_vector_2_u8(@Vector(2, u8), usize) void; +extern fn c_test_vector_2_u8() void; + +test "@Vector(2, u8)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest; + + const v = c_ret_vector_2_u8(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_u8(.{ 11, 12 }, 2); + c_test_vector_2_u8(); +} + +export fn zig_ret_vector_3_u8() @Vector(3, u8) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_u8(v: @Vector(3, u8), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_u8() @Vector(3, u8); +extern fn c_vector_3_u8(@Vector(3, u8), usize) void; +extern fn c_test_vector_3_u8() void; + +test "@Vector(3, u8)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest; + + const v = c_ret_vector_3_u8(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_u8(.{ 22, 23, 24 }, 3); + c_test_vector_3_u8(); +} + +export fn zig_ret_vector_4_u8() @Vector(4, u8) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_u8(v: @Vector(4, u8), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} +export fn zig_vector_4_u8_vector_4_u8(v0: @Vector(4, u8), v1: @Vector(4, u8), i: usize) void { + expect(v0[0] == 33) catch @panic("test failure"); + expect(v0[1] == 34) catch @panic("test failure"); + expect(v0[2] == 35) catch @panic("test failure"); + expect(v0[3] == 36) catch @panic("test failure"); + expect(v1[0] == 37) catch @panic("test failure"); + expect(v1[1] == 38) catch @panic("test failure"); + expect(v1[2] == 39) catch @panic("test failure"); + expect(v1[3] == 40) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_4_u8() @Vector(4, u8); +extern fn c_vector_4_u8(@Vector(4, u8), usize) void; +extern fn c_vector_4_u8_vector_4_u8(@Vector(4, u8), @Vector(4, u8), usize) void; +extern fn c_test_vector_4_u8() void; + +test "@Vector(4, u8)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest; + + const v = c_ret_vector_4_u8(); + try expect(v[0] == 41); + try expect(v[1] == 42); + try expect(v[2] == 43); + try expect(v[3] == 44); + c_vector_4_u8(.{ 45, 46, 47, 48 }, 4); + c_vector_4_u8_vector_4_u8(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8); + c_test_vector_4_u8(); +} + +export fn zig_ret_vector_6_u8() @Vector(6, u8) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_u8(v: @Vector(6, u8), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_u8() @Vector(6, u8); +extern fn c_vector_6_u8(@Vector(6, u8), usize) void; +extern fn c_test_vector_6_u8() void; + +test "@Vector(6, u8)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest; + + const v = c_ret_vector_6_u8(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_u8(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_u8(); +} + +export fn zig_ret_vector_8_u8() @Vector(8, u8) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_u8(v: @Vector(8, u8), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_u8() @Vector(8, u8); +extern fn c_vector_8_u8(@Vector(8, u8), usize) void; +extern fn c_test_vector_8_u8() void; + +test "@Vector(8, u8)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const v = c_ret_vector_8_u8(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_u8(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_u8(); +} + +export fn zig_ret_vector_12_u8() @Vector(12, u8) { + return .{ 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 }; +} +export fn zig_vector_12_u8(v: @Vector(12, u8), i: usize) void { + expect(v[0] == 9) catch @panic("test failure"); + expect(v[1] == 10) catch @panic("test failure"); + expect(v[2] == 11) catch @panic("test failure"); + expect(v[3] == 12) catch @panic("test failure"); + expect(v[4] == 13) catch @panic("test failure"); + expect(v[5] == 14) catch @panic("test failure"); + expect(v[6] == 15) catch @panic("test failure"); + expect(v[7] == 16) catch @panic("test failure"); + expect(v[8] == 17) catch @panic("test failure"); + expect(v[9] == 18) catch @panic("test failure"); + expect(v[10] == 19) catch @panic("test failure"); + expect(v[11] == 20) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_u8() @Vector(12, u8); +extern fn c_vector_12_u8(@Vector(12, u8), usize) void; +extern fn c_test_vector_12_u8() void; + +test "@Vector(12, u8)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + + const v = c_ret_vector_12_u8(); + try expect(v[0] == 21); + try expect(v[1] == 22); + try expect(v[2] == 23); + try expect(v[3] == 24); + try expect(v[4] == 25); + try expect(v[5] == 26); + try expect(v[6] == 27); + try expect(v[7] == 28); + try expect(v[8] == 29); + try expect(v[9] == 30); + try expect(v[10] == 31); + try expect(v[11] == 32); + c_vector_12_u8(.{ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44 }, 12); + c_test_vector_12_u8(); +} + +export fn zig_ret_vector_16_u8() @Vector(16, u8) { + return .{ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 }; +} +export fn zig_vector_16_u8(v: @Vector(16, u8), i: usize) void { + expect(v[0] == 61) catch @panic("test failure"); + expect(v[1] == 62) catch @panic("test failure"); + expect(v[2] == 63) catch @panic("test failure"); + expect(v[3] == 64) catch @panic("test failure"); + expect(v[4] == 65) catch @panic("test failure"); + expect(v[5] == 66) catch @panic("test failure"); + expect(v[6] == 67) catch @panic("test failure"); + expect(v[7] == 68) catch @panic("test failure"); + expect(v[8] == 69) catch @panic("test failure"); + expect(v[9] == 70) catch @panic("test failure"); + expect(v[10] == 71) catch @panic("test failure"); + expect(v[11] == 72) catch @panic("test failure"); + expect(v[12] == 73) catch @panic("test failure"); + expect(v[13] == 74) catch @panic("test failure"); + expect(v[14] == 75) catch @panic("test failure"); + expect(v[15] == 76) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_u8() @Vector(16, u8); +extern fn c_vector_16_u8(@Vector(16, u8), usize) void; +extern fn c_test_vector_16_u8() void; + +test "@Vector(16, u8)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_16_u8(); + try expect(v[0] == 77); + try expect(v[1] == 78); + try expect(v[2] == 79); + try expect(v[3] == 80); + try expect(v[4] == 81); + try expect(v[5] == 82); + try expect(v[6] == 83); + try expect(v[7] == 84); + try expect(v[8] == 85); + try expect(v[9] == 86); + try expect(v[10] == 87); + try expect(v[11] == 88); + try expect(v[12] == 89); + try expect(v[13] == 90); + try expect(v[14] == 91); + try expect(v[15] == 92); + c_vector_16_u8(.{ 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 }, 16); + c_test_vector_16_u8(); +} + +export fn zig_ret_vector_24_u8() @Vector(24, u8) { + return .{ + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, + }; +} +export fn zig_vector_24_u8(v: @Vector(24, u8), i: usize) void { + expect(v[0] == 33) catch @panic("test failure"); + expect(v[1] == 34) catch @panic("test failure"); + expect(v[2] == 35) catch @panic("test failure"); + expect(v[3] == 36) catch @panic("test failure"); + expect(v[4] == 37) catch @panic("test failure"); + expect(v[5] == 38) catch @panic("test failure"); + expect(v[6] == 39) catch @panic("test failure"); + expect(v[7] == 40) catch @panic("test failure"); + expect(v[8] == 41) catch @panic("test failure"); + expect(v[9] == 42) catch @panic("test failure"); + expect(v[10] == 43) catch @panic("test failure"); + expect(v[11] == 44) catch @panic("test failure"); + expect(v[12] == 45) catch @panic("test failure"); + expect(v[13] == 46) catch @panic("test failure"); + expect(v[14] == 47) catch @panic("test failure"); + expect(v[15] == 48) catch @panic("test failure"); + expect(v[16] == 49) catch @panic("test failure"); + expect(v[17] == 50) catch @panic("test failure"); + expect(v[18] == 51) catch @panic("test failure"); + expect(v[19] == 52) catch @panic("test failure"); + expect(v[20] == 53) catch @panic("test failure"); + expect(v[21] == 54) catch @panic("test failure"); + expect(v[22] == 55) catch @panic("test failure"); + expect(v[23] == 56) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_u8() @Vector(24, u8); +extern fn c_vector_24_u8(@Vector(24, u8), usize) void; +extern fn c_test_vector_24_u8() void; + +test "@Vector(24, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_24_u8(); + try expect(v[0] == 57); + try expect(v[1] == 58); + try expect(v[2] == 59); + try expect(v[3] == 60); + try expect(v[4] == 61); + try expect(v[5] == 62); + try expect(v[6] == 63); + try expect(v[7] == 64); + try expect(v[8] == 65); + try expect(v[9] == 66); + try expect(v[10] == 67); + try expect(v[11] == 68); + try expect(v[12] == 69); + try expect(v[13] == 70); + try expect(v[14] == 71); + try expect(v[15] == 72); + try expect(v[16] == 73); + try expect(v[17] == 74); + try expect(v[18] == 75); + try expect(v[19] == 76); + try expect(v[20] == 77); + try expect(v[21] == 78); + try expect(v[22] == 79); + try expect(v[23] == 80); + c_vector_24_u8(.{ + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 0, 1, 2, 3, 4, + }, 24); + c_test_vector_24_u8(); +} + +export fn zig_ret_vector_32_u8() @Vector(32, u8) { + return .{ + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + }; +} +export fn zig_vector_32_u8(v: @Vector(32, u8), i: usize) void { + expect(v[0] == 37) catch @panic("test failure"); + expect(v[1] == 38) catch @panic("test failure"); + expect(v[2] == 39) catch @panic("test failure"); + expect(v[3] == 40) catch @panic("test failure"); + expect(v[4] == 41) catch @panic("test failure"); + expect(v[5] == 42) catch @panic("test failure"); + expect(v[6] == 43) catch @panic("test failure"); + expect(v[7] == 44) catch @panic("test failure"); + expect(v[8] == 45) catch @panic("test failure"); + expect(v[9] == 46) catch @panic("test failure"); + expect(v[10] == 47) catch @panic("test failure"); + expect(v[11] == 48) catch @panic("test failure"); + expect(v[12] == 49) catch @panic("test failure"); + expect(v[13] == 50) catch @panic("test failure"); + expect(v[14] == 51) catch @panic("test failure"); + expect(v[15] == 52) catch @panic("test failure"); + expect(v[16] == 53) catch @panic("test failure"); + expect(v[17] == 54) catch @panic("test failure"); + expect(v[18] == 55) catch @panic("test failure"); + expect(v[19] == 56) catch @panic("test failure"); + expect(v[20] == 57) catch @panic("test failure"); + expect(v[21] == 58) catch @panic("test failure"); + expect(v[22] == 59) catch @panic("test failure"); + expect(v[23] == 60) catch @panic("test failure"); + expect(v[24] == 61) catch @panic("test failure"); + expect(v[25] == 62) catch @panic("test failure"); + expect(v[26] == 63) catch @panic("test failure"); + expect(v[27] == 64) catch @panic("test failure"); + expect(v[28] == 65) catch @panic("test failure"); + expect(v[29] == 66) catch @panic("test failure"); + expect(v[30] == 67) catch @panic("test failure"); + expect(v[31] == 68) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_u8() @Vector(32, u8); +extern fn c_vector_32_u8(@Vector(32, u8), usize) void; +extern fn c_test_vector_32_u8() void; + +test "@Vector(32, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_u8(); + try expect(v[0] == 69); + try expect(v[1] == 70); + try expect(v[2] == 71); + try expect(v[3] == 72); + try expect(v[4] == 73); + try expect(v[5] == 74); + try expect(v[6] == 75); + try expect(v[7] == 76); + try expect(v[8] == 77); + try expect(v[9] == 78); + try expect(v[10] == 79); + try expect(v[11] == 80); + try expect(v[12] == 81); + try expect(v[13] == 82); + try expect(v[14] == 83); + try expect(v[15] == 84); + try expect(v[16] == 85); + try expect(v[17] == 86); + try expect(v[18] == 87); + try expect(v[19] == 88); + try expect(v[20] == 89); + try expect(v[21] == 90); + try expect(v[22] == 91); + try expect(v[23] == 92); + try expect(v[24] == 93); + try expect(v[25] == 94); + try expect(v[26] == 95); + try expect(v[27] == 96); + try expect(v[28] == 97); + try expect(v[29] == 98); + try expect(v[30] == 99); + try expect(v[31] == 0); + c_vector_32_u8(.{ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + }, 32); + c_test_vector_32_u8(); +} + +export fn zig_ret_vector_48_u8() @Vector(48, u8) { + return .{ + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + }; +} +export fn zig_vector_48_u8(v: @Vector(48, u8), i: usize) void { + expect(v[0] == 81) catch @panic("test failure"); + expect(v[1] == 82) catch @panic("test failure"); + expect(v[2] == 83) catch @panic("test failure"); + expect(v[3] == 84) catch @panic("test failure"); + expect(v[4] == 85) catch @panic("test failure"); + expect(v[5] == 86) catch @panic("test failure"); + expect(v[6] == 87) catch @panic("test failure"); + expect(v[7] == 88) catch @panic("test failure"); + expect(v[8] == 89) catch @panic("test failure"); + expect(v[9] == 90) catch @panic("test failure"); + expect(v[10] == 91) catch @panic("test failure"); + expect(v[11] == 92) catch @panic("test failure"); + expect(v[12] == 93) catch @panic("test failure"); + expect(v[13] == 94) catch @panic("test failure"); + expect(v[14] == 95) catch @panic("test failure"); + expect(v[15] == 96) catch @panic("test failure"); + expect(v[16] == 97) catch @panic("test failure"); + expect(v[17] == 98) catch @panic("test failure"); + expect(v[18] == 99) catch @panic("test failure"); + expect(v[19] == 0) catch @panic("test failure"); + expect(v[20] == 1) catch @panic("test failure"); + expect(v[21] == 2) catch @panic("test failure"); + expect(v[22] == 3) catch @panic("test failure"); + expect(v[23] == 4) catch @panic("test failure"); + expect(v[24] == 5) catch @panic("test failure"); + expect(v[25] == 6) catch @panic("test failure"); + expect(v[26] == 7) catch @panic("test failure"); + expect(v[27] == 8) catch @panic("test failure"); + expect(v[28] == 9) catch @panic("test failure"); + expect(v[29] == 10) catch @panic("test failure"); + expect(v[30] == 11) catch @panic("test failure"); + expect(v[31] == 12) catch @panic("test failure"); + expect(v[32] == 13) catch @panic("test failure"); + expect(v[33] == 14) catch @panic("test failure"); + expect(v[34] == 15) catch @panic("test failure"); + expect(v[35] == 16) catch @panic("test failure"); + expect(v[36] == 17) catch @panic("test failure"); + expect(v[37] == 18) catch @panic("test failure"); + expect(v[38] == 19) catch @panic("test failure"); + expect(v[39] == 20) catch @panic("test failure"); + expect(v[40] == 21) catch @panic("test failure"); + expect(v[41] == 22) catch @panic("test failure"); + expect(v[42] == 23) catch @panic("test failure"); + expect(v[43] == 24) catch @panic("test failure"); + expect(v[44] == 25) catch @panic("test failure"); + expect(v[45] == 26) catch @panic("test failure"); + expect(v[46] == 27) catch @panic("test failure"); + expect(v[47] == 28) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_u8() @Vector(48, u8); +extern fn c_vector_48_u8(@Vector(48, u8), usize) void; +extern fn c_test_vector_48_u8() void; + +test "@Vector(48, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_48_u8(); + try expect(v[0] == 29); + try expect(v[1] == 30); + try expect(v[2] == 31); + try expect(v[3] == 32); + try expect(v[4] == 33); + try expect(v[5] == 34); + try expect(v[6] == 35); + try expect(v[7] == 36); + try expect(v[8] == 37); + try expect(v[9] == 38); + try expect(v[10] == 39); + try expect(v[11] == 40); + try expect(v[12] == 41); + try expect(v[13] == 42); + try expect(v[14] == 43); + try expect(v[15] == 44); + try expect(v[16] == 45); + try expect(v[17] == 46); + try expect(v[18] == 47); + try expect(v[19] == 48); + try expect(v[20] == 49); + try expect(v[21] == 50); + try expect(v[22] == 51); + try expect(v[23] == 52); + try expect(v[24] == 53); + try expect(v[25] == 54); + try expect(v[26] == 55); + try expect(v[27] == 56); + try expect(v[28] == 57); + try expect(v[29] == 58); + try expect(v[30] == 59); + try expect(v[31] == 60); + try expect(v[32] == 61); + try expect(v[33] == 62); + try expect(v[34] == 63); + try expect(v[35] == 64); + try expect(v[36] == 65); + try expect(v[37] == 66); + try expect(v[38] == 67); + try expect(v[39] == 68); + try expect(v[40] == 69); + try expect(v[41] == 70); + try expect(v[42] == 71); + try expect(v[43] == 72); + try expect(v[44] == 73); + try expect(v[45] == 74); + try expect(v[46] == 75); + try expect(v[47] == 76); + c_vector_48_u8(.{ + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + }, 48); + c_test_vector_48_u8(); +} + +export fn zig_ret_vector_64_u8() @Vector(64, u8) { + return .{ + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + }; +} +export fn zig_vector_64_u8(v: @Vector(64, u8), i: usize) void { + expect(v[0] == 89) catch @panic("test failure"); + expect(v[1] == 90) catch @panic("test failure"); + expect(v[2] == 91) catch @panic("test failure"); + expect(v[3] == 92) catch @panic("test failure"); + expect(v[4] == 93) catch @panic("test failure"); + expect(v[5] == 94) catch @panic("test failure"); + expect(v[6] == 95) catch @panic("test failure"); + expect(v[7] == 96) catch @panic("test failure"); + expect(v[8] == 97) catch @panic("test failure"); + expect(v[9] == 98) catch @panic("test failure"); + expect(v[10] == 99) catch @panic("test failure"); + expect(v[11] == 0) catch @panic("test failure"); + expect(v[12] == 1) catch @panic("test failure"); + expect(v[13] == 2) catch @panic("test failure"); + expect(v[14] == 3) catch @panic("test failure"); + expect(v[15] == 4) catch @panic("test failure"); + expect(v[16] == 5) catch @panic("test failure"); + expect(v[17] == 6) catch @panic("test failure"); + expect(v[18] == 7) catch @panic("test failure"); + expect(v[19] == 8) catch @panic("test failure"); + expect(v[20] == 9) catch @panic("test failure"); + expect(v[21] == 10) catch @panic("test failure"); + expect(v[22] == 11) catch @panic("test failure"); + expect(v[23] == 12) catch @panic("test failure"); + expect(v[24] == 13) catch @panic("test failure"); + expect(v[25] == 14) catch @panic("test failure"); + expect(v[26] == 15) catch @panic("test failure"); + expect(v[27] == 16) catch @panic("test failure"); + expect(v[28] == 17) catch @panic("test failure"); + expect(v[29] == 18) catch @panic("test failure"); + expect(v[30] == 19) catch @panic("test failure"); + expect(v[31] == 20) catch @panic("test failure"); + expect(v[32] == 21) catch @panic("test failure"); + expect(v[33] == 22) catch @panic("test failure"); + expect(v[34] == 23) catch @panic("test failure"); + expect(v[35] == 24) catch @panic("test failure"); + expect(v[36] == 25) catch @panic("test failure"); + expect(v[37] == 26) catch @panic("test failure"); + expect(v[38] == 27) catch @panic("test failure"); + expect(v[39] == 28) catch @panic("test failure"); + expect(v[40] == 29) catch @panic("test failure"); + expect(v[41] == 30) catch @panic("test failure"); + expect(v[42] == 31) catch @panic("test failure"); + expect(v[43] == 32) catch @panic("test failure"); + expect(v[44] == 33) catch @panic("test failure"); + expect(v[45] == 34) catch @panic("test failure"); + expect(v[46] == 35) catch @panic("test failure"); + expect(v[47] == 36) catch @panic("test failure"); + expect(v[48] == 37) catch @panic("test failure"); + expect(v[49] == 38) catch @panic("test failure"); + expect(v[50] == 39) catch @panic("test failure"); + expect(v[51] == 40) catch @panic("test failure"); + expect(v[52] == 41) catch @panic("test failure"); + expect(v[53] == 42) catch @panic("test failure"); + expect(v[54] == 43) catch @panic("test failure"); + expect(v[55] == 44) catch @panic("test failure"); + expect(v[56] == 45) catch @panic("test failure"); + expect(v[57] == 46) catch @panic("test failure"); + expect(v[58] == 47) catch @panic("test failure"); + expect(v[59] == 48) catch @panic("test failure"); + expect(v[60] == 49) catch @panic("test failure"); + expect(v[61] == 50) catch @panic("test failure"); + expect(v[62] == 51) catch @panic("test failure"); + expect(v[63] == 52) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_u8() @Vector(64, u8); +extern fn c_vector_64_u8(@Vector(64, u8), usize) void; +extern fn c_test_vector_64_u8() void; + +test "@Vector(64, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_u8(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + try expect(v[6] == 59); + try expect(v[7] == 60); + try expect(v[8] == 61); + try expect(v[9] == 62); + try expect(v[10] == 63); + try expect(v[11] == 64); + try expect(v[12] == 65); + try expect(v[13] == 66); + try expect(v[14] == 67); + try expect(v[15] == 68); + try expect(v[16] == 69); + try expect(v[17] == 70); + try expect(v[18] == 71); + try expect(v[19] == 72); + try expect(v[20] == 73); + try expect(v[21] == 74); + try expect(v[22] == 75); + try expect(v[23] == 76); + try expect(v[24] == 77); + try expect(v[25] == 78); + try expect(v[26] == 79); + try expect(v[27] == 80); + try expect(v[28] == 81); + try expect(v[29] == 82); + try expect(v[30] == 83); + try expect(v[31] == 84); + try expect(v[32] == 85); + try expect(v[33] == 86); + try expect(v[34] == 87); + try expect(v[35] == 88); + try expect(v[36] == 89); + try expect(v[37] == 90); + try expect(v[38] == 91); + try expect(v[39] == 92); + try expect(v[40] == 93); + try expect(v[41] == 94); + try expect(v[42] == 95); + try expect(v[43] == 96); + try expect(v[44] == 97); + try expect(v[45] == 98); + try expect(v[46] == 99); + try expect(v[47] == 0); + try expect(v[48] == 1); + try expect(v[49] == 2); + try expect(v[50] == 3); + try expect(v[51] == 4); + try expect(v[52] == 5); + try expect(v[53] == 6); + try expect(v[54] == 7); + try expect(v[55] == 8); + try expect(v[56] == 9); + try expect(v[57] == 10); + try expect(v[58] == 11); + try expect(v[59] == 12); + try expect(v[60] == 13); + try expect(v[61] == 14); + try expect(v[62] == 15); + try expect(v[63] == 16); + c_vector_64_u8(.{ + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + }, 64); + c_test_vector_64_u8(); +} + +export fn zig_ret_vector_96_u8() @Vector(96, u8) { + return .{ + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + }; +} +export fn zig_vector_96_u8(v: @Vector(96, u8), i: usize) void { + expect(v[0] == 86) catch @panic("test failure"); + expect(v[1] == 87) catch @panic("test failure"); + expect(v[2] == 88) catch @panic("test failure"); + expect(v[3] == 89) catch @panic("test failure"); + expect(v[4] == 90) catch @panic("test failure"); + expect(v[5] == 91) catch @panic("test failure"); + expect(v[6] == 92) catch @panic("test failure"); + expect(v[7] == 93) catch @panic("test failure"); + expect(v[8] == 94) catch @panic("test failure"); + expect(v[9] == 95) catch @panic("test failure"); + expect(v[10] == 96) catch @panic("test failure"); + expect(v[11] == 97) catch @panic("test failure"); + expect(v[12] == 98) catch @panic("test failure"); + expect(v[13] == 99) catch @panic("test failure"); + expect(v[14] == 0) catch @panic("test failure"); + expect(v[15] == 1) catch @panic("test failure"); + expect(v[16] == 2) catch @panic("test failure"); + expect(v[17] == 3) catch @panic("test failure"); + expect(v[18] == 4) catch @panic("test failure"); + expect(v[19] == 5) catch @panic("test failure"); + expect(v[20] == 6) catch @panic("test failure"); + expect(v[21] == 7) catch @panic("test failure"); + expect(v[22] == 8) catch @panic("test failure"); + expect(v[23] == 9) catch @panic("test failure"); + expect(v[24] == 10) catch @panic("test failure"); + expect(v[25] == 11) catch @panic("test failure"); + expect(v[26] == 12) catch @panic("test failure"); + expect(v[27] == 13) catch @panic("test failure"); + expect(v[28] == 14) catch @panic("test failure"); + expect(v[29] == 15) catch @panic("test failure"); + expect(v[30] == 16) catch @panic("test failure"); + expect(v[31] == 17) catch @panic("test failure"); + expect(v[32] == 18) catch @panic("test failure"); + expect(v[33] == 19) catch @panic("test failure"); + expect(v[34] == 20) catch @panic("test failure"); + expect(v[35] == 21) catch @panic("test failure"); + expect(v[36] == 22) catch @panic("test failure"); + expect(v[37] == 23) catch @panic("test failure"); + expect(v[38] == 24) catch @panic("test failure"); + expect(v[39] == 25) catch @panic("test failure"); + expect(v[40] == 26) catch @panic("test failure"); + expect(v[41] == 27) catch @panic("test failure"); + expect(v[42] == 28) catch @panic("test failure"); + expect(v[43] == 29) catch @panic("test failure"); + expect(v[44] == 30) catch @panic("test failure"); + expect(v[45] == 31) catch @panic("test failure"); + expect(v[46] == 32) catch @panic("test failure"); + expect(v[47] == 33) catch @panic("test failure"); + expect(v[48] == 34) catch @panic("test failure"); + expect(v[49] == 35) catch @panic("test failure"); + expect(v[50] == 36) catch @panic("test failure"); + expect(v[51] == 37) catch @panic("test failure"); + expect(v[52] == 38) catch @panic("test failure"); + expect(v[53] == 39) catch @panic("test failure"); + expect(v[54] == 40) catch @panic("test failure"); + expect(v[55] == 41) catch @panic("test failure"); + expect(v[56] == 42) catch @panic("test failure"); + expect(v[57] == 43) catch @panic("test failure"); + expect(v[58] == 44) catch @panic("test failure"); + expect(v[59] == 45) catch @panic("test failure"); + expect(v[60] == 46) catch @panic("test failure"); + expect(v[61] == 47) catch @panic("test failure"); + expect(v[62] == 48) catch @panic("test failure"); + expect(v[63] == 49) catch @panic("test failure"); + expect(v[64] == 50) catch @panic("test failure"); + expect(v[65] == 51) catch @panic("test failure"); + expect(v[66] == 52) catch @panic("test failure"); + expect(v[67] == 53) catch @panic("test failure"); + expect(v[68] == 54) catch @panic("test failure"); + expect(v[69] == 55) catch @panic("test failure"); + expect(v[70] == 56) catch @panic("test failure"); + expect(v[71] == 57) catch @panic("test failure"); + expect(v[72] == 58) catch @panic("test failure"); + expect(v[73] == 59) catch @panic("test failure"); + expect(v[74] == 60) catch @panic("test failure"); + expect(v[75] == 61) catch @panic("test failure"); + expect(v[76] == 62) catch @panic("test failure"); + expect(v[77] == 63) catch @panic("test failure"); + expect(v[78] == 64) catch @panic("test failure"); + expect(v[79] == 65) catch @panic("test failure"); + expect(v[80] == 66) catch @panic("test failure"); + expect(v[81] == 67) catch @panic("test failure"); + expect(v[82] == 68) catch @panic("test failure"); + expect(v[83] == 69) catch @panic("test failure"); + expect(v[84] == 70) catch @panic("test failure"); + expect(v[85] == 71) catch @panic("test failure"); + expect(v[86] == 72) catch @panic("test failure"); + expect(v[87] == 73) catch @panic("test failure"); + expect(v[88] == 74) catch @panic("test failure"); + expect(v[89] == 75) catch @panic("test failure"); + expect(v[90] == 76) catch @panic("test failure"); + expect(v[91] == 77) catch @panic("test failure"); + expect(v[92] == 78) catch @panic("test failure"); + expect(v[93] == 79) catch @panic("test failure"); + expect(v[94] == 80) catch @panic("test failure"); + expect(v[95] == 81) catch @panic("test failure"); + expect(i == 96) catch @panic("test failure"); +} + +extern fn c_ret_vector_96_u8() @Vector(96, u8); +extern fn c_vector_96_u8(@Vector(96, u8), usize) void; +extern fn c_test_vector_96_u8() void; + +test "@Vector(96, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_96_u8(); + try expect(v[0] == 82); + try expect(v[1] == 83); + try expect(v[2] == 84); + try expect(v[3] == 85); + try expect(v[4] == 86); + try expect(v[5] == 87); + try expect(v[6] == 88); + try expect(v[7] == 89); + try expect(v[8] == 90); + try expect(v[9] == 91); + try expect(v[10] == 92); + try expect(v[11] == 93); + try expect(v[12] == 94); + try expect(v[13] == 95); + try expect(v[14] == 96); + try expect(v[15] == 97); + try expect(v[16] == 98); + try expect(v[17] == 99); + try expect(v[18] == 0); + try expect(v[19] == 1); + try expect(v[20] == 2); + try expect(v[21] == 3); + try expect(v[22] == 4); + try expect(v[23] == 5); + try expect(v[24] == 6); + try expect(v[25] == 7); + try expect(v[26] == 8); + try expect(v[27] == 9); + try expect(v[28] == 10); + try expect(v[29] == 11); + try expect(v[30] == 12); + try expect(v[31] == 13); + try expect(v[32] == 14); + try expect(v[33] == 15); + try expect(v[34] == 16); + try expect(v[35] == 17); + try expect(v[36] == 18); + try expect(v[37] == 19); + try expect(v[38] == 20); + try expect(v[39] == 21); + try expect(v[40] == 22); + try expect(v[41] == 23); + try expect(v[42] == 24); + try expect(v[43] == 25); + try expect(v[44] == 26); + try expect(v[45] == 27); + try expect(v[46] == 28); + try expect(v[47] == 29); + try expect(v[48] == 30); + try expect(v[49] == 31); + try expect(v[50] == 32); + try expect(v[51] == 33); + try expect(v[52] == 34); + try expect(v[53] == 35); + try expect(v[54] == 36); + try expect(v[55] == 37); + try expect(v[56] == 38); + try expect(v[57] == 39); + try expect(v[58] == 40); + try expect(v[59] == 41); + try expect(v[60] == 42); + try expect(v[61] == 43); + try expect(v[62] == 44); + try expect(v[63] == 45); + try expect(v[64] == 46); + try expect(v[65] == 47); + try expect(v[66] == 48); + try expect(v[67] == 49); + try expect(v[68] == 50); + try expect(v[69] == 51); + try expect(v[70] == 52); + try expect(v[71] == 53); + try expect(v[72] == 54); + try expect(v[73] == 55); + try expect(v[74] == 56); + try expect(v[75] == 57); + try expect(v[76] == 58); + try expect(v[77] == 59); + try expect(v[78] == 60); + try expect(v[79] == 61); + try expect(v[80] == 62); + try expect(v[81] == 63); + try expect(v[82] == 64); + try expect(v[83] == 65); + try expect(v[84] == 66); + try expect(v[85] == 67); + try expect(v[86] == 68); + try expect(v[87] == 69); + try expect(v[88] == 70); + try expect(v[89] == 71); + try expect(v[90] == 72); + try expect(v[91] == 73); + try expect(v[92] == 74); + try expect(v[93] == 75); + try expect(v[94] == 76); + try expect(v[95] == 77); + c_vector_96_u8(.{ + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + }, 96); + c_test_vector_96_u8(); +} + +export fn zig_ret_vector_128_u8() @Vector(128, u8) { + return .{ + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + }; +} +export fn zig_vector_128_u8(v: @Vector(128, u8), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(v[1] == 3) catch @panic("test failure"); + expect(v[2] == 4) catch @panic("test failure"); + expect(v[3] == 5) catch @panic("test failure"); + expect(v[4] == 6) catch @panic("test failure"); + expect(v[5] == 7) catch @panic("test failure"); + expect(v[6] == 8) catch @panic("test failure"); + expect(v[7] == 9) catch @panic("test failure"); + expect(v[8] == 10) catch @panic("test failure"); + expect(v[9] == 11) catch @panic("test failure"); + expect(v[10] == 12) catch @panic("test failure"); + expect(v[11] == 13) catch @panic("test failure"); + expect(v[12] == 14) catch @panic("test failure"); + expect(v[13] == 15) catch @panic("test failure"); + expect(v[14] == 16) catch @panic("test failure"); + expect(v[15] == 17) catch @panic("test failure"); + expect(v[16] == 18) catch @panic("test failure"); + expect(v[17] == 19) catch @panic("test failure"); + expect(v[18] == 20) catch @panic("test failure"); + expect(v[19] == 21) catch @panic("test failure"); + expect(v[20] == 22) catch @panic("test failure"); + expect(v[21] == 23) catch @panic("test failure"); + expect(v[22] == 24) catch @panic("test failure"); + expect(v[23] == 25) catch @panic("test failure"); + expect(v[24] == 26) catch @panic("test failure"); + expect(v[25] == 27) catch @panic("test failure"); + expect(v[26] == 28) catch @panic("test failure"); + expect(v[27] == 29) catch @panic("test failure"); + expect(v[28] == 30) catch @panic("test failure"); + expect(v[29] == 31) catch @panic("test failure"); + expect(v[30] == 32) catch @panic("test failure"); + expect(v[31] == 33) catch @panic("test failure"); + expect(v[32] == 34) catch @panic("test failure"); + expect(v[33] == 35) catch @panic("test failure"); + expect(v[34] == 36) catch @panic("test failure"); + expect(v[35] == 37) catch @panic("test failure"); + expect(v[36] == 38) catch @panic("test failure"); + expect(v[37] == 39) catch @panic("test failure"); + expect(v[38] == 40) catch @panic("test failure"); + expect(v[39] == 41) catch @panic("test failure"); + expect(v[40] == 42) catch @panic("test failure"); + expect(v[41] == 43) catch @panic("test failure"); + expect(v[42] == 44) catch @panic("test failure"); + expect(v[43] == 45) catch @panic("test failure"); + expect(v[44] == 46) catch @panic("test failure"); + expect(v[45] == 47) catch @panic("test failure"); + expect(v[46] == 48) catch @panic("test failure"); + expect(v[47] == 49) catch @panic("test failure"); + expect(v[48] == 50) catch @panic("test failure"); + expect(v[49] == 51) catch @panic("test failure"); + expect(v[50] == 52) catch @panic("test failure"); + expect(v[51] == 53) catch @panic("test failure"); + expect(v[52] == 54) catch @panic("test failure"); + expect(v[53] == 55) catch @panic("test failure"); + expect(v[54] == 56) catch @panic("test failure"); + expect(v[55] == 57) catch @panic("test failure"); + expect(v[56] == 58) catch @panic("test failure"); + expect(v[57] == 59) catch @panic("test failure"); + expect(v[58] == 60) catch @panic("test failure"); + expect(v[59] == 61) catch @panic("test failure"); + expect(v[60] == 62) catch @panic("test failure"); + expect(v[61] == 63) catch @panic("test failure"); + expect(v[62] == 64) catch @panic("test failure"); + expect(v[63] == 65) catch @panic("test failure"); + expect(v[64] == 66) catch @panic("test failure"); + expect(v[65] == 67) catch @panic("test failure"); + expect(v[66] == 68) catch @panic("test failure"); + expect(v[67] == 69) catch @panic("test failure"); + expect(v[68] == 70) catch @panic("test failure"); + expect(v[69] == 71) catch @panic("test failure"); + expect(v[70] == 72) catch @panic("test failure"); + expect(v[71] == 73) catch @panic("test failure"); + expect(v[72] == 74) catch @panic("test failure"); + expect(v[73] == 75) catch @panic("test failure"); + expect(v[74] == 76) catch @panic("test failure"); + expect(v[75] == 77) catch @panic("test failure"); + expect(v[76] == 78) catch @panic("test failure"); + expect(v[77] == 79) catch @panic("test failure"); + expect(v[78] == 80) catch @panic("test failure"); + expect(v[79] == 81) catch @panic("test failure"); + expect(v[80] == 82) catch @panic("test failure"); + expect(v[81] == 83) catch @panic("test failure"); + expect(v[82] == 84) catch @panic("test failure"); + expect(v[83] == 85) catch @panic("test failure"); + expect(v[84] == 86) catch @panic("test failure"); + expect(v[85] == 87) catch @panic("test failure"); + expect(v[86] == 88) catch @panic("test failure"); + expect(v[87] == 89) catch @panic("test failure"); + expect(v[88] == 90) catch @panic("test failure"); + expect(v[89] == 91) catch @panic("test failure"); + expect(v[90] == 92) catch @panic("test failure"); + expect(v[91] == 93) catch @panic("test failure"); + expect(v[92] == 94) catch @panic("test failure"); + expect(v[93] == 95) catch @panic("test failure"); + expect(v[94] == 96) catch @panic("test failure"); + expect(v[95] == 97) catch @panic("test failure"); + expect(v[96] == 98) catch @panic("test failure"); + expect(v[97] == 99) catch @panic("test failure"); + expect(v[98] == 0) catch @panic("test failure"); + expect(v[99] == 1) catch @panic("test failure"); + expect(v[100] == 2) catch @panic("test failure"); + expect(v[101] == 3) catch @panic("test failure"); + expect(v[102] == 4) catch @panic("test failure"); + expect(v[103] == 5) catch @panic("test failure"); + expect(v[104] == 6) catch @panic("test failure"); + expect(v[105] == 7) catch @panic("test failure"); + expect(v[106] == 8) catch @panic("test failure"); + expect(v[107] == 9) catch @panic("test failure"); + expect(v[108] == 10) catch @panic("test failure"); + expect(v[109] == 11) catch @panic("test failure"); + expect(v[110] == 12) catch @panic("test failure"); + expect(v[111] == 13) catch @panic("test failure"); + expect(v[112] == 14) catch @panic("test failure"); + expect(v[113] == 15) catch @panic("test failure"); + expect(v[114] == 16) catch @panic("test failure"); + expect(v[115] == 17) catch @panic("test failure"); + expect(v[116] == 18) catch @panic("test failure"); + expect(v[117] == 19) catch @panic("test failure"); + expect(v[118] == 20) catch @panic("test failure"); + expect(v[119] == 21) catch @panic("test failure"); + expect(v[120] == 22) catch @panic("test failure"); + expect(v[121] == 23) catch @panic("test failure"); + expect(v[122] == 24) catch @panic("test failure"); + expect(v[123] == 25) catch @panic("test failure"); + expect(v[124] == 26) catch @panic("test failure"); + expect(v[125] == 27) catch @panic("test failure"); + expect(v[126] == 28) catch @panic("test failure"); + expect(v[127] == 29) catch @panic("test failure"); + expect(i == 128) catch @panic("test failure"); +} + +extern fn c_ret_vector_128_u8() @Vector(128, u8); +extern fn c_vector_128_u8(@Vector(128, u8), usize) void; +extern fn c_test_vector_128_u8() void; + +test "@Vector(128, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_128_u8(); + try expect(v[0] == 30); + try expect(v[1] == 31); + try expect(v[2] == 32); + try expect(v[3] == 33); + try expect(v[4] == 34); + try expect(v[5] == 35); + try expect(v[6] == 36); + try expect(v[7] == 37); + try expect(v[8] == 38); + try expect(v[9] == 39); + try expect(v[10] == 40); + try expect(v[11] == 41); + try expect(v[12] == 42); + try expect(v[13] == 43); + try expect(v[14] == 44); + try expect(v[15] == 45); + try expect(v[16] == 46); + try expect(v[17] == 47); + try expect(v[18] == 48); + try expect(v[19] == 49); + try expect(v[20] == 50); + try expect(v[21] == 51); + try expect(v[22] == 52); + try expect(v[23] == 53); + try expect(v[24] == 54); + try expect(v[25] == 55); + try expect(v[26] == 56); + try expect(v[27] == 57); + try expect(v[28] == 58); + try expect(v[29] == 59); + try expect(v[30] == 60); + try expect(v[31] == 61); + try expect(v[32] == 62); + try expect(v[33] == 63); + try expect(v[34] == 64); + try expect(v[35] == 65); + try expect(v[36] == 66); + try expect(v[37] == 67); + try expect(v[38] == 68); + try expect(v[39] == 69); + try expect(v[40] == 70); + try expect(v[41] == 71); + try expect(v[42] == 72); + try expect(v[43] == 73); + try expect(v[44] == 74); + try expect(v[45] == 75); + try expect(v[46] == 76); + try expect(v[47] == 77); + try expect(v[48] == 78); + try expect(v[49] == 79); + try expect(v[50] == 80); + try expect(v[51] == 81); + try expect(v[52] == 82); + try expect(v[53] == 83); + try expect(v[54] == 84); + try expect(v[55] == 85); + try expect(v[56] == 86); + try expect(v[57] == 87); + try expect(v[58] == 88); + try expect(v[59] == 89); + try expect(v[60] == 90); + try expect(v[61] == 91); + try expect(v[62] == 92); + try expect(v[63] == 93); + try expect(v[64] == 94); + try expect(v[65] == 95); + try expect(v[66] == 96); + try expect(v[67] == 97); + try expect(v[68] == 98); + try expect(v[69] == 99); + try expect(v[70] == 0); + try expect(v[71] == 1); + try expect(v[72] == 2); + try expect(v[73] == 3); + try expect(v[74] == 4); + try expect(v[75] == 5); + try expect(v[76] == 6); + try expect(v[77] == 7); + try expect(v[78] == 8); + try expect(v[79] == 9); + try expect(v[80] == 10); + try expect(v[81] == 11); + try expect(v[82] == 12); + try expect(v[83] == 13); + try expect(v[84] == 14); + try expect(v[85] == 15); + try expect(v[86] == 16); + try expect(v[87] == 17); + try expect(v[88] == 18); + try expect(v[89] == 19); + try expect(v[90] == 20); + try expect(v[91] == 21); + try expect(v[92] == 22); + try expect(v[93] == 23); + try expect(v[94] == 24); + try expect(v[95] == 25); + try expect(v[96] == 26); + try expect(v[97] == 27); + try expect(v[98] == 28); + try expect(v[99] == 29); + try expect(v[100] == 30); + try expect(v[101] == 31); + try expect(v[102] == 32); + try expect(v[103] == 33); + try expect(v[104] == 34); + try expect(v[105] == 35); + try expect(v[106] == 36); + try expect(v[107] == 37); + try expect(v[108] == 38); + try expect(v[109] == 39); + try expect(v[110] == 40); + try expect(v[111] == 41); + try expect(v[112] == 42); + try expect(v[113] == 43); + try expect(v[114] == 44); + try expect(v[115] == 45); + try expect(v[116] == 46); + try expect(v[117] == 47); + try expect(v[118] == 48); + try expect(v[119] == 49); + try expect(v[120] == 50); + try expect(v[121] == 51); + try expect(v[122] == 52); + try expect(v[123] == 53); + try expect(v[124] == 54); + try expect(v[125] == 55); + try expect(v[126] == 56); + try expect(v[127] == 57); + c_vector_128_u8(.{ + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + }, 128); + c_test_vector_128_u8(); +} + +export fn zig_ret_vector_192_u8() @Vector(192, u8) { + return .{ + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + }; +} +export fn zig_vector_192_u8(v: @Vector(192, u8), i: usize) void { + expect(v[0] == 78) catch @panic("test failure"); + expect(v[1] == 79) catch @panic("test failure"); + expect(v[2] == 80) catch @panic("test failure"); + expect(v[3] == 81) catch @panic("test failure"); + expect(v[4] == 82) catch @panic("test failure"); + expect(v[5] == 83) catch @panic("test failure"); + expect(v[6] == 84) catch @panic("test failure"); + expect(v[7] == 85) catch @panic("test failure"); + expect(v[8] == 86) catch @panic("test failure"); + expect(v[9] == 87) catch @panic("test failure"); + expect(v[10] == 88) catch @panic("test failure"); + expect(v[11] == 89) catch @panic("test failure"); + expect(v[12] == 90) catch @panic("test failure"); + expect(v[13] == 91) catch @panic("test failure"); + expect(v[14] == 92) catch @panic("test failure"); + expect(v[15] == 93) catch @panic("test failure"); + expect(v[16] == 94) catch @panic("test failure"); + expect(v[17] == 95) catch @panic("test failure"); + expect(v[18] == 96) catch @panic("test failure"); + expect(v[19] == 97) catch @panic("test failure"); + expect(v[20] == 98) catch @panic("test failure"); + expect(v[21] == 99) catch @panic("test failure"); + expect(v[22] == 0) catch @panic("test failure"); + expect(v[23] == 1) catch @panic("test failure"); + expect(v[24] == 2) catch @panic("test failure"); + expect(v[25] == 3) catch @panic("test failure"); + expect(v[26] == 4) catch @panic("test failure"); + expect(v[27] == 5) catch @panic("test failure"); + expect(v[28] == 6) catch @panic("test failure"); + expect(v[29] == 7) catch @panic("test failure"); + expect(v[30] == 8) catch @panic("test failure"); + expect(v[31] == 9) catch @panic("test failure"); + expect(v[32] == 10) catch @panic("test failure"); + expect(v[33] == 11) catch @panic("test failure"); + expect(v[34] == 12) catch @panic("test failure"); + expect(v[35] == 13) catch @panic("test failure"); + expect(v[36] == 14) catch @panic("test failure"); + expect(v[37] == 15) catch @panic("test failure"); + expect(v[38] == 16) catch @panic("test failure"); + expect(v[39] == 17) catch @panic("test failure"); + expect(v[40] == 18) catch @panic("test failure"); + expect(v[41] == 19) catch @panic("test failure"); + expect(v[42] == 20) catch @panic("test failure"); + expect(v[43] == 21) catch @panic("test failure"); + expect(v[44] == 22) catch @panic("test failure"); + expect(v[45] == 23) catch @panic("test failure"); + expect(v[46] == 24) catch @panic("test failure"); + expect(v[47] == 25) catch @panic("test failure"); + expect(v[48] == 26) catch @panic("test failure"); + expect(v[49] == 27) catch @panic("test failure"); + expect(v[50] == 28) catch @panic("test failure"); + expect(v[51] == 29) catch @panic("test failure"); + expect(v[52] == 30) catch @panic("test failure"); + expect(v[53] == 31) catch @panic("test failure"); + expect(v[54] == 32) catch @panic("test failure"); + expect(v[55] == 33) catch @panic("test failure"); + expect(v[56] == 34) catch @panic("test failure"); + expect(v[57] == 35) catch @panic("test failure"); + expect(v[58] == 36) catch @panic("test failure"); + expect(v[59] == 37) catch @panic("test failure"); + expect(v[60] == 38) catch @panic("test failure"); + expect(v[61] == 39) catch @panic("test failure"); + expect(v[62] == 40) catch @panic("test failure"); + expect(v[63] == 41) catch @panic("test failure"); + expect(v[64] == 42) catch @panic("test failure"); + expect(v[65] == 43) catch @panic("test failure"); + expect(v[66] == 44) catch @panic("test failure"); + expect(v[67] == 45) catch @panic("test failure"); + expect(v[68] == 46) catch @panic("test failure"); + expect(v[69] == 47) catch @panic("test failure"); + expect(v[70] == 48) catch @panic("test failure"); + expect(v[71] == 49) catch @panic("test failure"); + expect(v[72] == 50) catch @panic("test failure"); + expect(v[73] == 51) catch @panic("test failure"); + expect(v[74] == 52) catch @panic("test failure"); + expect(v[75] == 53) catch @panic("test failure"); + expect(v[76] == 54) catch @panic("test failure"); + expect(v[77] == 55) catch @panic("test failure"); + expect(v[78] == 56) catch @panic("test failure"); + expect(v[79] == 57) catch @panic("test failure"); + expect(v[80] == 58) catch @panic("test failure"); + expect(v[81] == 59) catch @panic("test failure"); + expect(v[82] == 60) catch @panic("test failure"); + expect(v[83] == 61) catch @panic("test failure"); + expect(v[84] == 62) catch @panic("test failure"); + expect(v[85] == 63) catch @panic("test failure"); + expect(v[86] == 64) catch @panic("test failure"); + expect(v[87] == 65) catch @panic("test failure"); + expect(v[88] == 66) catch @panic("test failure"); + expect(v[89] == 67) catch @panic("test failure"); + expect(v[90] == 68) catch @panic("test failure"); + expect(v[91] == 69) catch @panic("test failure"); + expect(v[92] == 70) catch @panic("test failure"); + expect(v[93] == 71) catch @panic("test failure"); + expect(v[94] == 72) catch @panic("test failure"); + expect(v[95] == 73) catch @panic("test failure"); + expect(v[96] == 74) catch @panic("test failure"); + expect(v[97] == 75) catch @panic("test failure"); + expect(v[98] == 76) catch @panic("test failure"); + expect(v[99] == 77) catch @panic("test failure"); + expect(v[100] == 78) catch @panic("test failure"); + expect(v[101] == 79) catch @panic("test failure"); + expect(v[102] == 80) catch @panic("test failure"); + expect(v[103] == 81) catch @panic("test failure"); + expect(v[104] == 82) catch @panic("test failure"); + expect(v[105] == 83) catch @panic("test failure"); + expect(v[106] == 84) catch @panic("test failure"); + expect(v[107] == 85) catch @panic("test failure"); + expect(v[108] == 86) catch @panic("test failure"); + expect(v[109] == 87) catch @panic("test failure"); + expect(v[110] == 88) catch @panic("test failure"); + expect(v[111] == 89) catch @panic("test failure"); + expect(v[112] == 90) catch @panic("test failure"); + expect(v[113] == 91) catch @panic("test failure"); + expect(v[114] == 92) catch @panic("test failure"); + expect(v[115] == 93) catch @panic("test failure"); + expect(v[116] == 94) catch @panic("test failure"); + expect(v[117] == 95) catch @panic("test failure"); + expect(v[118] == 96) catch @panic("test failure"); + expect(v[119] == 97) catch @panic("test failure"); + expect(v[120] == 98) catch @panic("test failure"); + expect(v[121] == 99) catch @panic("test failure"); + expect(v[122] == 0) catch @panic("test failure"); + expect(v[123] == 1) catch @panic("test failure"); + expect(v[124] == 2) catch @panic("test failure"); + expect(v[125] == 3) catch @panic("test failure"); + expect(v[126] == 4) catch @panic("test failure"); + expect(v[127] == 5) catch @panic("test failure"); + expect(v[128] == 6) catch @panic("test failure"); + expect(v[129] == 7) catch @panic("test failure"); + expect(v[130] == 8) catch @panic("test failure"); + expect(v[131] == 9) catch @panic("test failure"); + expect(v[132] == 10) catch @panic("test failure"); + expect(v[133] == 11) catch @panic("test failure"); + expect(v[134] == 12) catch @panic("test failure"); + expect(v[135] == 13) catch @panic("test failure"); + expect(v[136] == 14) catch @panic("test failure"); + expect(v[137] == 15) catch @panic("test failure"); + expect(v[138] == 16) catch @panic("test failure"); + expect(v[139] == 17) catch @panic("test failure"); + expect(v[140] == 18) catch @panic("test failure"); + expect(v[141] == 19) catch @panic("test failure"); + expect(v[142] == 20) catch @panic("test failure"); + expect(v[143] == 21) catch @panic("test failure"); + expect(v[144] == 22) catch @panic("test failure"); + expect(v[145] == 23) catch @panic("test failure"); + expect(v[146] == 24) catch @panic("test failure"); + expect(v[147] == 25) catch @panic("test failure"); + expect(v[148] == 26) catch @panic("test failure"); + expect(v[149] == 27) catch @panic("test failure"); + expect(v[150] == 28) catch @panic("test failure"); + expect(v[151] == 29) catch @panic("test failure"); + expect(v[152] == 30) catch @panic("test failure"); + expect(v[153] == 31) catch @panic("test failure"); + expect(v[154] == 32) catch @panic("test failure"); + expect(v[155] == 33) catch @panic("test failure"); + expect(v[156] == 34) catch @panic("test failure"); + expect(v[157] == 35) catch @panic("test failure"); + expect(v[158] == 36) catch @panic("test failure"); + expect(v[159] == 37) catch @panic("test failure"); + expect(v[160] == 38) catch @panic("test failure"); + expect(v[161] == 39) catch @panic("test failure"); + expect(v[162] == 40) catch @panic("test failure"); + expect(v[163] == 41) catch @panic("test failure"); + expect(v[164] == 42) catch @panic("test failure"); + expect(v[165] == 43) catch @panic("test failure"); + expect(v[166] == 44) catch @panic("test failure"); + expect(v[167] == 45) catch @panic("test failure"); + expect(v[168] == 46) catch @panic("test failure"); + expect(v[169] == 47) catch @panic("test failure"); + expect(v[170] == 48) catch @panic("test failure"); + expect(v[171] == 49) catch @panic("test failure"); + expect(v[172] == 50) catch @panic("test failure"); + expect(v[173] == 51) catch @panic("test failure"); + expect(v[174] == 52) catch @panic("test failure"); + expect(v[175] == 53) catch @panic("test failure"); + expect(v[176] == 54) catch @panic("test failure"); + expect(v[177] == 55) catch @panic("test failure"); + expect(v[178] == 56) catch @panic("test failure"); + expect(v[179] == 57) catch @panic("test failure"); + expect(v[180] == 58) catch @panic("test failure"); + expect(v[181] == 59) catch @panic("test failure"); + expect(v[182] == 60) catch @panic("test failure"); + expect(v[183] == 61) catch @panic("test failure"); + expect(v[184] == 62) catch @panic("test failure"); + expect(v[185] == 63) catch @panic("test failure"); + expect(v[186] == 64) catch @panic("test failure"); + expect(v[187] == 65) catch @panic("test failure"); + expect(v[188] == 66) catch @panic("test failure"); + expect(v[189] == 67) catch @panic("test failure"); + expect(v[190] == 68) catch @panic("test failure"); + expect(v[191] == 69) catch @panic("test failure"); + expect(i == 192) catch @panic("test failure"); +} + +extern fn c_ret_vector_192_u8() @Vector(192, u8); +extern fn c_vector_192_u8(@Vector(192, u8), usize) void; +extern fn c_test_vector_192_u8() void; + +test "@Vector(192, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_192_u8(); + try expect(v[0] == 70); + try expect(v[1] == 71); + try expect(v[2] == 72); + try expect(v[3] == 73); + try expect(v[4] == 74); + try expect(v[5] == 75); + try expect(v[6] == 76); + try expect(v[7] == 77); + try expect(v[8] == 78); + try expect(v[9] == 79); + try expect(v[10] == 80); + try expect(v[11] == 81); + try expect(v[12] == 82); + try expect(v[13] == 83); + try expect(v[14] == 84); + try expect(v[15] == 85); + try expect(v[16] == 86); + try expect(v[17] == 87); + try expect(v[18] == 88); + try expect(v[19] == 89); + try expect(v[20] == 90); + try expect(v[21] == 91); + try expect(v[22] == 92); + try expect(v[23] == 93); + try expect(v[24] == 94); + try expect(v[25] == 95); + try expect(v[26] == 96); + try expect(v[27] == 97); + try expect(v[28] == 98); + try expect(v[29] == 99); + try expect(v[30] == 0); + try expect(v[31] == 1); + try expect(v[32] == 2); + try expect(v[33] == 3); + try expect(v[34] == 4); + try expect(v[35] == 5); + try expect(v[36] == 6); + try expect(v[37] == 7); + try expect(v[38] == 8); + try expect(v[39] == 9); + try expect(v[40] == 10); + try expect(v[41] == 11); + try expect(v[42] == 12); + try expect(v[43] == 13); + try expect(v[44] == 14); + try expect(v[45] == 15); + try expect(v[46] == 16); + try expect(v[47] == 17); + try expect(v[48] == 18); + try expect(v[49] == 19); + try expect(v[50] == 20); + try expect(v[51] == 21); + try expect(v[52] == 22); + try expect(v[53] == 23); + try expect(v[54] == 24); + try expect(v[55] == 25); + try expect(v[56] == 26); + try expect(v[57] == 27); + try expect(v[58] == 28); + try expect(v[59] == 29); + try expect(v[60] == 30); + try expect(v[61] == 31); + try expect(v[62] == 32); + try expect(v[63] == 33); + try expect(v[64] == 34); + try expect(v[65] == 35); + try expect(v[66] == 36); + try expect(v[67] == 37); + try expect(v[68] == 38); + try expect(v[69] == 39); + try expect(v[70] == 40); + try expect(v[71] == 41); + try expect(v[72] == 42); + try expect(v[73] == 43); + try expect(v[74] == 44); + try expect(v[75] == 45); + try expect(v[76] == 46); + try expect(v[77] == 47); + try expect(v[78] == 48); + try expect(v[79] == 49); + try expect(v[80] == 50); + try expect(v[81] == 51); + try expect(v[82] == 52); + try expect(v[83] == 53); + try expect(v[84] == 54); + try expect(v[85] == 55); + try expect(v[86] == 56); + try expect(v[87] == 57); + try expect(v[88] == 58); + try expect(v[89] == 59); + try expect(v[90] == 60); + try expect(v[91] == 61); + try expect(v[92] == 62); + try expect(v[93] == 63); + try expect(v[94] == 64); + try expect(v[95] == 65); + try expect(v[96] == 66); + try expect(v[97] == 67); + try expect(v[98] == 68); + try expect(v[99] == 69); + try expect(v[100] == 70); + try expect(v[101] == 71); + try expect(v[102] == 72); + try expect(v[103] == 73); + try expect(v[104] == 74); + try expect(v[105] == 75); + try expect(v[106] == 76); + try expect(v[107] == 77); + try expect(v[108] == 78); + try expect(v[109] == 79); + try expect(v[110] == 80); + try expect(v[111] == 81); + try expect(v[112] == 82); + try expect(v[113] == 83); + try expect(v[114] == 84); + try expect(v[115] == 85); + try expect(v[116] == 86); + try expect(v[117] == 87); + try expect(v[118] == 88); + try expect(v[119] == 89); + try expect(v[120] == 90); + try expect(v[121] == 91); + try expect(v[122] == 92); + try expect(v[123] == 93); + try expect(v[124] == 94); + try expect(v[125] == 95); + try expect(v[126] == 96); + try expect(v[127] == 97); + try expect(v[128] == 98); + try expect(v[129] == 99); + try expect(v[130] == 0); + try expect(v[131] == 1); + try expect(v[132] == 2); + try expect(v[133] == 3); + try expect(v[134] == 4); + try expect(v[135] == 5); + try expect(v[136] == 6); + try expect(v[137] == 7); + try expect(v[138] == 8); + try expect(v[139] == 9); + try expect(v[140] == 10); + try expect(v[141] == 11); + try expect(v[142] == 12); + try expect(v[143] == 13); + try expect(v[144] == 14); + try expect(v[145] == 15); + try expect(v[146] == 16); + try expect(v[147] == 17); + try expect(v[148] == 18); + try expect(v[149] == 19); + try expect(v[150] == 20); + try expect(v[151] == 21); + try expect(v[152] == 22); + try expect(v[153] == 23); + try expect(v[154] == 24); + try expect(v[155] == 25); + try expect(v[156] == 26); + try expect(v[157] == 27); + try expect(v[158] == 28); + try expect(v[159] == 29); + try expect(v[160] == 30); + try expect(v[161] == 31); + try expect(v[162] == 32); + try expect(v[163] == 33); + try expect(v[164] == 34); + try expect(v[165] == 35); + try expect(v[166] == 36); + try expect(v[167] == 37); + try expect(v[168] == 38); + try expect(v[169] == 39); + try expect(v[170] == 40); + try expect(v[171] == 41); + try expect(v[172] == 42); + try expect(v[173] == 43); + try expect(v[174] == 44); + try expect(v[175] == 45); + try expect(v[176] == 46); + try expect(v[177] == 47); + try expect(v[178] == 48); + try expect(v[179] == 49); + try expect(v[180] == 50); + try expect(v[181] == 51); + try expect(v[182] == 52); + try expect(v[183] == 53); + try expect(v[184] == 54); + try expect(v[185] == 55); + try expect(v[186] == 56); + try expect(v[187] == 57); + try expect(v[188] == 58); + try expect(v[189] == 59); + try expect(v[190] == 60); + try expect(v[191] == 61); + c_vector_192_u8(.{ + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + }, 192); + c_test_vector_192_u8(); +} + +export fn zig_ret_vector_256_u8() @Vector(256, u8) { + return .{ + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + }; +} +export fn zig_vector_256_u8(v: @Vector(256, u8), i: usize) void { + expect(v[0] == 10) catch @panic("test failure"); + expect(v[1] == 11) catch @panic("test failure"); + expect(v[2] == 12) catch @panic("test failure"); + expect(v[3] == 13) catch @panic("test failure"); + expect(v[4] == 14) catch @panic("test failure"); + expect(v[5] == 15) catch @panic("test failure"); + expect(v[6] == 16) catch @panic("test failure"); + expect(v[7] == 17) catch @panic("test failure"); + expect(v[8] == 18) catch @panic("test failure"); + expect(v[9] == 19) catch @panic("test failure"); + expect(v[10] == 20) catch @panic("test failure"); + expect(v[11] == 21) catch @panic("test failure"); + expect(v[12] == 22) catch @panic("test failure"); + expect(v[13] == 23) catch @panic("test failure"); + expect(v[14] == 24) catch @panic("test failure"); + expect(v[15] == 25) catch @panic("test failure"); + expect(v[16] == 26) catch @panic("test failure"); + expect(v[17] == 27) catch @panic("test failure"); + expect(v[18] == 28) catch @panic("test failure"); + expect(v[19] == 29) catch @panic("test failure"); + expect(v[20] == 30) catch @panic("test failure"); + expect(v[21] == 31) catch @panic("test failure"); + expect(v[22] == 32) catch @panic("test failure"); + expect(v[23] == 33) catch @panic("test failure"); + expect(v[24] == 34) catch @panic("test failure"); + expect(v[25] == 35) catch @panic("test failure"); + expect(v[26] == 36) catch @panic("test failure"); + expect(v[27] == 37) catch @panic("test failure"); + expect(v[28] == 38) catch @panic("test failure"); + expect(v[29] == 39) catch @panic("test failure"); + expect(v[30] == 40) catch @panic("test failure"); + expect(v[31] == 41) catch @panic("test failure"); + expect(v[32] == 42) catch @panic("test failure"); + expect(v[33] == 43) catch @panic("test failure"); + expect(v[34] == 44) catch @panic("test failure"); + expect(v[35] == 45) catch @panic("test failure"); + expect(v[36] == 46) catch @panic("test failure"); + expect(v[37] == 47) catch @panic("test failure"); + expect(v[38] == 48) catch @panic("test failure"); + expect(v[39] == 49) catch @panic("test failure"); + expect(v[40] == 50) catch @panic("test failure"); + expect(v[41] == 51) catch @panic("test failure"); + expect(v[42] == 52) catch @panic("test failure"); + expect(v[43] == 53) catch @panic("test failure"); + expect(v[44] == 54) catch @panic("test failure"); + expect(v[45] == 55) catch @panic("test failure"); + expect(v[46] == 56) catch @panic("test failure"); + expect(v[47] == 57) catch @panic("test failure"); + expect(v[48] == 58) catch @panic("test failure"); + expect(v[49] == 59) catch @panic("test failure"); + expect(v[50] == 60) catch @panic("test failure"); + expect(v[51] == 61) catch @panic("test failure"); + expect(v[52] == 62) catch @panic("test failure"); + expect(v[53] == 63) catch @panic("test failure"); + expect(v[54] == 64) catch @panic("test failure"); + expect(v[55] == 65) catch @panic("test failure"); + expect(v[56] == 66) catch @panic("test failure"); + expect(v[57] == 67) catch @panic("test failure"); + expect(v[58] == 68) catch @panic("test failure"); + expect(v[59] == 69) catch @panic("test failure"); + expect(v[60] == 70) catch @panic("test failure"); + expect(v[61] == 71) catch @panic("test failure"); + expect(v[62] == 72) catch @panic("test failure"); + expect(v[63] == 73) catch @panic("test failure"); + expect(v[64] == 74) catch @panic("test failure"); + expect(v[65] == 75) catch @panic("test failure"); + expect(v[66] == 76) catch @panic("test failure"); + expect(v[67] == 77) catch @panic("test failure"); + expect(v[68] == 78) catch @panic("test failure"); + expect(v[69] == 79) catch @panic("test failure"); + expect(v[70] == 80) catch @panic("test failure"); + expect(v[71] == 81) catch @panic("test failure"); + expect(v[72] == 82) catch @panic("test failure"); + expect(v[73] == 83) catch @panic("test failure"); + expect(v[74] == 84) catch @panic("test failure"); + expect(v[75] == 85) catch @panic("test failure"); + expect(v[76] == 86) catch @panic("test failure"); + expect(v[77] == 87) catch @panic("test failure"); + expect(v[78] == 88) catch @panic("test failure"); + expect(v[79] == 89) catch @panic("test failure"); + expect(v[80] == 90) catch @panic("test failure"); + expect(v[81] == 91) catch @panic("test failure"); + expect(v[82] == 92) catch @panic("test failure"); + expect(v[83] == 93) catch @panic("test failure"); + expect(v[84] == 94) catch @panic("test failure"); + expect(v[85] == 95) catch @panic("test failure"); + expect(v[86] == 96) catch @panic("test failure"); + expect(v[87] == 97) catch @panic("test failure"); + expect(v[88] == 98) catch @panic("test failure"); + expect(v[89] == 99) catch @panic("test failure"); + expect(v[90] == 0) catch @panic("test failure"); + expect(v[91] == 1) catch @panic("test failure"); + expect(v[92] == 2) catch @panic("test failure"); + expect(v[93] == 3) catch @panic("test failure"); + expect(v[94] == 4) catch @panic("test failure"); + expect(v[95] == 5) catch @panic("test failure"); + expect(v[96] == 6) catch @panic("test failure"); + expect(v[97] == 7) catch @panic("test failure"); + expect(v[98] == 8) catch @panic("test failure"); + expect(v[99] == 9) catch @panic("test failure"); + expect(v[100] == 10) catch @panic("test failure"); + expect(v[101] == 11) catch @panic("test failure"); + expect(v[102] == 12) catch @panic("test failure"); + expect(v[103] == 13) catch @panic("test failure"); + expect(v[104] == 14) catch @panic("test failure"); + expect(v[105] == 15) catch @panic("test failure"); + expect(v[106] == 16) catch @panic("test failure"); + expect(v[107] == 17) catch @panic("test failure"); + expect(v[108] == 18) catch @panic("test failure"); + expect(v[109] == 19) catch @panic("test failure"); + expect(v[110] == 20) catch @panic("test failure"); + expect(v[111] == 21) catch @panic("test failure"); + expect(v[112] == 22) catch @panic("test failure"); + expect(v[113] == 23) catch @panic("test failure"); + expect(v[114] == 24) catch @panic("test failure"); + expect(v[115] == 25) catch @panic("test failure"); + expect(v[116] == 26) catch @panic("test failure"); + expect(v[117] == 27) catch @panic("test failure"); + expect(v[118] == 28) catch @panic("test failure"); + expect(v[119] == 29) catch @panic("test failure"); + expect(v[120] == 30) catch @panic("test failure"); + expect(v[121] == 31) catch @panic("test failure"); + expect(v[122] == 32) catch @panic("test failure"); + expect(v[123] == 33) catch @panic("test failure"); + expect(v[124] == 34) catch @panic("test failure"); + expect(v[125] == 35) catch @panic("test failure"); + expect(v[126] == 36) catch @panic("test failure"); + expect(v[127] == 37) catch @panic("test failure"); + expect(v[128] == 38) catch @panic("test failure"); + expect(v[129] == 39) catch @panic("test failure"); + expect(v[130] == 40) catch @panic("test failure"); + expect(v[131] == 41) catch @panic("test failure"); + expect(v[132] == 42) catch @panic("test failure"); + expect(v[133] == 43) catch @panic("test failure"); + expect(v[134] == 44) catch @panic("test failure"); + expect(v[135] == 45) catch @panic("test failure"); + expect(v[136] == 46) catch @panic("test failure"); + expect(v[137] == 47) catch @panic("test failure"); + expect(v[138] == 48) catch @panic("test failure"); + expect(v[139] == 49) catch @panic("test failure"); + expect(v[140] == 50) catch @panic("test failure"); + expect(v[141] == 51) catch @panic("test failure"); + expect(v[142] == 52) catch @panic("test failure"); + expect(v[143] == 53) catch @panic("test failure"); + expect(v[144] == 54) catch @panic("test failure"); + expect(v[145] == 55) catch @panic("test failure"); + expect(v[146] == 56) catch @panic("test failure"); + expect(v[147] == 57) catch @panic("test failure"); + expect(v[148] == 58) catch @panic("test failure"); + expect(v[149] == 59) catch @panic("test failure"); + expect(v[150] == 60) catch @panic("test failure"); + expect(v[151] == 61) catch @panic("test failure"); + expect(v[152] == 62) catch @panic("test failure"); + expect(v[153] == 63) catch @panic("test failure"); + expect(v[154] == 64) catch @panic("test failure"); + expect(v[155] == 65) catch @panic("test failure"); + expect(v[156] == 66) catch @panic("test failure"); + expect(v[157] == 67) catch @panic("test failure"); + expect(v[158] == 68) catch @panic("test failure"); + expect(v[159] == 69) catch @panic("test failure"); + expect(v[160] == 70) catch @panic("test failure"); + expect(v[161] == 71) catch @panic("test failure"); + expect(v[162] == 72) catch @panic("test failure"); + expect(v[163] == 73) catch @panic("test failure"); + expect(v[164] == 74) catch @panic("test failure"); + expect(v[165] == 75) catch @panic("test failure"); + expect(v[166] == 76) catch @panic("test failure"); + expect(v[167] == 77) catch @panic("test failure"); + expect(v[168] == 78) catch @panic("test failure"); + expect(v[169] == 79) catch @panic("test failure"); + expect(v[170] == 80) catch @panic("test failure"); + expect(v[171] == 81) catch @panic("test failure"); + expect(v[172] == 82) catch @panic("test failure"); + expect(v[173] == 83) catch @panic("test failure"); + expect(v[174] == 84) catch @panic("test failure"); + expect(v[175] == 85) catch @panic("test failure"); + expect(v[176] == 86) catch @panic("test failure"); + expect(v[177] == 87) catch @panic("test failure"); + expect(v[178] == 88) catch @panic("test failure"); + expect(v[179] == 89) catch @panic("test failure"); + expect(v[180] == 90) catch @panic("test failure"); + expect(v[181] == 91) catch @panic("test failure"); + expect(v[182] == 92) catch @panic("test failure"); + expect(v[183] == 93) catch @panic("test failure"); + expect(v[184] == 94) catch @panic("test failure"); + expect(v[185] == 95) catch @panic("test failure"); + expect(v[186] == 96) catch @panic("test failure"); + expect(v[187] == 97) catch @panic("test failure"); + expect(v[188] == 98) catch @panic("test failure"); + expect(v[189] == 99) catch @panic("test failure"); + expect(v[190] == 0) catch @panic("test failure"); + expect(v[191] == 1) catch @panic("test failure"); + expect(v[192] == 2) catch @panic("test failure"); + expect(v[193] == 3) catch @panic("test failure"); + expect(v[194] == 4) catch @panic("test failure"); + expect(v[195] == 5) catch @panic("test failure"); + expect(v[196] == 6) catch @panic("test failure"); + expect(v[197] == 7) catch @panic("test failure"); + expect(v[198] == 8) catch @panic("test failure"); + expect(v[199] == 9) catch @panic("test failure"); + expect(v[200] == 10) catch @panic("test failure"); + expect(v[201] == 11) catch @panic("test failure"); + expect(v[202] == 12) catch @panic("test failure"); + expect(v[203] == 13) catch @panic("test failure"); + expect(v[204] == 14) catch @panic("test failure"); + expect(v[205] == 15) catch @panic("test failure"); + expect(v[206] == 16) catch @panic("test failure"); + expect(v[207] == 17) catch @panic("test failure"); + expect(v[208] == 18) catch @panic("test failure"); + expect(v[209] == 19) catch @panic("test failure"); + expect(v[210] == 20) catch @panic("test failure"); + expect(v[211] == 21) catch @panic("test failure"); + expect(v[212] == 22) catch @panic("test failure"); + expect(v[213] == 23) catch @panic("test failure"); + expect(v[214] == 24) catch @panic("test failure"); + expect(v[215] == 25) catch @panic("test failure"); + expect(v[216] == 26) catch @panic("test failure"); + expect(v[217] == 27) catch @panic("test failure"); + expect(v[218] == 28) catch @panic("test failure"); + expect(v[219] == 29) catch @panic("test failure"); + expect(v[220] == 30) catch @panic("test failure"); + expect(v[221] == 31) catch @panic("test failure"); + expect(v[222] == 32) catch @panic("test failure"); + expect(v[223] == 33) catch @panic("test failure"); + expect(v[224] == 34) catch @panic("test failure"); + expect(v[225] == 35) catch @panic("test failure"); + expect(v[226] == 36) catch @panic("test failure"); + expect(v[227] == 37) catch @panic("test failure"); + expect(v[228] == 38) catch @panic("test failure"); + expect(v[229] == 39) catch @panic("test failure"); + expect(v[230] == 40) catch @panic("test failure"); + expect(v[231] == 41) catch @panic("test failure"); + expect(v[232] == 42) catch @panic("test failure"); + expect(v[233] == 43) catch @panic("test failure"); + expect(v[234] == 44) catch @panic("test failure"); + expect(v[235] == 45) catch @panic("test failure"); + expect(v[236] == 46) catch @panic("test failure"); + expect(v[237] == 47) catch @panic("test failure"); + expect(v[238] == 48) catch @panic("test failure"); + expect(v[239] == 49) catch @panic("test failure"); + expect(v[240] == 50) catch @panic("test failure"); + expect(v[241] == 51) catch @panic("test failure"); + expect(v[242] == 52) catch @panic("test failure"); + expect(v[243] == 53) catch @panic("test failure"); + expect(v[244] == 54) catch @panic("test failure"); + expect(v[245] == 55) catch @panic("test failure"); + expect(v[246] == 56) catch @panic("test failure"); + expect(v[247] == 57) catch @panic("test failure"); + expect(v[248] == 58) catch @panic("test failure"); + expect(v[249] == 59) catch @panic("test failure"); + expect(v[250] == 60) catch @panic("test failure"); + expect(v[251] == 61) catch @panic("test failure"); + expect(v[252] == 62) catch @panic("test failure"); + expect(v[253] == 63) catch @panic("test failure"); + expect(v[254] == 64) catch @panic("test failure"); + expect(v[255] == 65) catch @panic("test failure"); + expect(i == 256) catch @panic("test failure"); +} + +extern fn c_ret_vector_256_u8() @Vector(256, u8); +extern fn c_vector_256_u8(@Vector(256, u8), usize) void; +extern fn c_test_vector_256_u8() void; + +test "@Vector(256, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_256_u8(); + try expect(v[0] == 66); + try expect(v[1] == 67); + try expect(v[2] == 68); + try expect(v[3] == 69); + try expect(v[4] == 70); + try expect(v[5] == 71); + try expect(v[6] == 72); + try expect(v[7] == 73); + try expect(v[8] == 74); + try expect(v[9] == 75); + try expect(v[10] == 76); + try expect(v[11] == 77); + try expect(v[12] == 78); + try expect(v[13] == 79); + try expect(v[14] == 80); + try expect(v[15] == 81); + try expect(v[16] == 82); + try expect(v[17] == 83); + try expect(v[18] == 84); + try expect(v[19] == 85); + try expect(v[20] == 86); + try expect(v[21] == 87); + try expect(v[22] == 88); + try expect(v[23] == 89); + try expect(v[24] == 90); + try expect(v[25] == 91); + try expect(v[26] == 92); + try expect(v[27] == 93); + try expect(v[28] == 94); + try expect(v[29] == 95); + try expect(v[30] == 96); + try expect(v[31] == 97); + try expect(v[32] == 98); + try expect(v[33] == 99); + try expect(v[34] == 0); + try expect(v[35] == 1); + try expect(v[36] == 2); + try expect(v[37] == 3); + try expect(v[38] == 4); + try expect(v[39] == 5); + try expect(v[40] == 6); + try expect(v[41] == 7); + try expect(v[42] == 8); + try expect(v[43] == 9); + try expect(v[44] == 10); + try expect(v[45] == 11); + try expect(v[46] == 12); + try expect(v[47] == 13); + try expect(v[48] == 14); + try expect(v[49] == 15); + try expect(v[50] == 16); + try expect(v[51] == 17); + try expect(v[52] == 18); + try expect(v[53] == 19); + try expect(v[54] == 20); + try expect(v[55] == 21); + try expect(v[56] == 22); + try expect(v[57] == 23); + try expect(v[58] == 24); + try expect(v[59] == 25); + try expect(v[60] == 26); + try expect(v[61] == 27); + try expect(v[62] == 28); + try expect(v[63] == 29); + try expect(v[64] == 30); + try expect(v[65] == 31); + try expect(v[66] == 32); + try expect(v[67] == 33); + try expect(v[68] == 34); + try expect(v[69] == 35); + try expect(v[70] == 36); + try expect(v[71] == 37); + try expect(v[72] == 38); + try expect(v[73] == 39); + try expect(v[74] == 40); + try expect(v[75] == 41); + try expect(v[76] == 42); + try expect(v[77] == 43); + try expect(v[78] == 44); + try expect(v[79] == 45); + try expect(v[80] == 46); + try expect(v[81] == 47); + try expect(v[82] == 48); + try expect(v[83] == 49); + try expect(v[84] == 50); + try expect(v[85] == 51); + try expect(v[86] == 52); + try expect(v[87] == 53); + try expect(v[88] == 54); + try expect(v[89] == 55); + try expect(v[90] == 56); + try expect(v[91] == 57); + try expect(v[92] == 58); + try expect(v[93] == 59); + try expect(v[94] == 60); + try expect(v[95] == 61); + try expect(v[96] == 62); + try expect(v[97] == 63); + try expect(v[98] == 64); + try expect(v[99] == 65); + try expect(v[100] == 66); + try expect(v[101] == 67); + try expect(v[102] == 68); + try expect(v[103] == 69); + try expect(v[104] == 70); + try expect(v[105] == 71); + try expect(v[106] == 72); + try expect(v[107] == 73); + try expect(v[108] == 74); + try expect(v[109] == 75); + try expect(v[110] == 76); + try expect(v[111] == 77); + try expect(v[112] == 78); + try expect(v[113] == 79); + try expect(v[114] == 80); + try expect(v[115] == 81); + try expect(v[116] == 82); + try expect(v[117] == 83); + try expect(v[118] == 84); + try expect(v[119] == 85); + try expect(v[120] == 86); + try expect(v[121] == 87); + try expect(v[122] == 88); + try expect(v[123] == 89); + try expect(v[124] == 90); + try expect(v[125] == 91); + try expect(v[126] == 92); + try expect(v[127] == 93); + try expect(v[128] == 94); + try expect(v[129] == 95); + try expect(v[130] == 96); + try expect(v[131] == 97); + try expect(v[132] == 98); + try expect(v[133] == 99); + try expect(v[134] == 0); + try expect(v[135] == 1); + try expect(v[136] == 2); + try expect(v[137] == 3); + try expect(v[138] == 4); + try expect(v[139] == 5); + try expect(v[140] == 6); + try expect(v[141] == 7); + try expect(v[142] == 8); + try expect(v[143] == 9); + try expect(v[144] == 10); + try expect(v[145] == 11); + try expect(v[146] == 12); + try expect(v[147] == 13); + try expect(v[148] == 14); + try expect(v[149] == 15); + try expect(v[150] == 16); + try expect(v[151] == 17); + try expect(v[152] == 18); + try expect(v[153] == 19); + try expect(v[154] == 20); + try expect(v[155] == 21); + try expect(v[156] == 22); + try expect(v[157] == 23); + try expect(v[158] == 24); + try expect(v[159] == 25); + try expect(v[160] == 26); + try expect(v[161] == 27); + try expect(v[162] == 28); + try expect(v[163] == 29); + try expect(v[164] == 30); + try expect(v[165] == 31); + try expect(v[166] == 32); + try expect(v[167] == 33); + try expect(v[168] == 34); + try expect(v[169] == 35); + try expect(v[170] == 36); + try expect(v[171] == 37); + try expect(v[172] == 38); + try expect(v[173] == 39); + try expect(v[174] == 40); + try expect(v[175] == 41); + try expect(v[176] == 42); + try expect(v[177] == 43); + try expect(v[178] == 44); + try expect(v[179] == 45); + try expect(v[180] == 46); + try expect(v[181] == 47); + try expect(v[182] == 48); + try expect(v[183] == 49); + try expect(v[184] == 50); + try expect(v[185] == 51); + try expect(v[186] == 52); + try expect(v[187] == 53); + try expect(v[188] == 54); + try expect(v[189] == 55); + try expect(v[190] == 56); + try expect(v[191] == 57); + try expect(v[192] == 58); + try expect(v[193] == 59); + try expect(v[194] == 60); + try expect(v[195] == 61); + try expect(v[196] == 62); + try expect(v[197] == 63); + try expect(v[198] == 64); + try expect(v[199] == 65); + try expect(v[200] == 66); + try expect(v[201] == 67); + try expect(v[202] == 68); + try expect(v[203] == 69); + try expect(v[204] == 70); + try expect(v[205] == 71); + try expect(v[206] == 72); + try expect(v[207] == 73); + try expect(v[208] == 74); + try expect(v[209] == 75); + try expect(v[210] == 76); + try expect(v[211] == 77); + try expect(v[212] == 78); + try expect(v[213] == 79); + try expect(v[214] == 80); + try expect(v[215] == 81); + try expect(v[216] == 82); + try expect(v[217] == 83); + try expect(v[218] == 84); + try expect(v[219] == 85); + try expect(v[220] == 86); + try expect(v[221] == 87); + try expect(v[222] == 88); + try expect(v[223] == 89); + try expect(v[224] == 90); + try expect(v[225] == 91); + try expect(v[226] == 92); + try expect(v[227] == 93); + try expect(v[228] == 94); + try expect(v[229] == 95); + try expect(v[230] == 96); + try expect(v[231] == 97); + try expect(v[232] == 98); + try expect(v[233] == 99); + try expect(v[234] == 0); + try expect(v[235] == 1); + try expect(v[236] == 2); + try expect(v[237] == 3); + try expect(v[238] == 4); + try expect(v[239] == 5); + try expect(v[240] == 6); + try expect(v[241] == 7); + try expect(v[242] == 8); + try expect(v[243] == 9); + try expect(v[244] == 10); + try expect(v[245] == 11); + try expect(v[246] == 12); + try expect(v[247] == 13); + try expect(v[248] == 14); + try expect(v[249] == 15); + try expect(v[250] == 16); + try expect(v[251] == 17); + try expect(v[252] == 18); + try expect(v[253] == 19); + try expect(v[254] == 20); + try expect(v[255] == 21); + c_vector_256_u8(.{ + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + }, 256); + c_test_vector_256_u8(); +} + +export fn zig_ret_vector_384_u8() @Vector(384, u8) { + return .{ + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + }; +} +export fn zig_vector_384_u8(v: @Vector(384, u8), i: usize) void { + expect(v[0] == 62) catch @panic("test failure"); + expect(v[1] == 63) catch @panic("test failure"); + expect(v[2] == 64) catch @panic("test failure"); + expect(v[3] == 65) catch @panic("test failure"); + expect(v[4] == 66) catch @panic("test failure"); + expect(v[5] == 67) catch @panic("test failure"); + expect(v[6] == 68) catch @panic("test failure"); + expect(v[7] == 69) catch @panic("test failure"); + expect(v[8] == 70) catch @panic("test failure"); + expect(v[9] == 71) catch @panic("test failure"); + expect(v[10] == 72) catch @panic("test failure"); + expect(v[11] == 73) catch @panic("test failure"); + expect(v[12] == 74) catch @panic("test failure"); + expect(v[13] == 75) catch @panic("test failure"); + expect(v[14] == 76) catch @panic("test failure"); + expect(v[15] == 77) catch @panic("test failure"); + expect(v[16] == 78) catch @panic("test failure"); + expect(v[17] == 79) catch @panic("test failure"); + expect(v[18] == 80) catch @panic("test failure"); + expect(v[19] == 81) catch @panic("test failure"); + expect(v[20] == 82) catch @panic("test failure"); + expect(v[21] == 83) catch @panic("test failure"); + expect(v[22] == 84) catch @panic("test failure"); + expect(v[23] == 85) catch @panic("test failure"); + expect(v[24] == 86) catch @panic("test failure"); + expect(v[25] == 87) catch @panic("test failure"); + expect(v[26] == 88) catch @panic("test failure"); + expect(v[27] == 89) catch @panic("test failure"); + expect(v[28] == 90) catch @panic("test failure"); + expect(v[29] == 91) catch @panic("test failure"); + expect(v[30] == 92) catch @panic("test failure"); + expect(v[31] == 93) catch @panic("test failure"); + expect(v[32] == 94) catch @panic("test failure"); + expect(v[33] == 95) catch @panic("test failure"); + expect(v[34] == 96) catch @panic("test failure"); + expect(v[35] == 97) catch @panic("test failure"); + expect(v[36] == 98) catch @panic("test failure"); + expect(v[37] == 99) catch @panic("test failure"); + expect(v[38] == 0) catch @panic("test failure"); + expect(v[39] == 1) catch @panic("test failure"); + expect(v[40] == 2) catch @panic("test failure"); + expect(v[41] == 3) catch @panic("test failure"); + expect(v[42] == 4) catch @panic("test failure"); + expect(v[43] == 5) catch @panic("test failure"); + expect(v[44] == 6) catch @panic("test failure"); + expect(v[45] == 7) catch @panic("test failure"); + expect(v[46] == 8) catch @panic("test failure"); + expect(v[47] == 9) catch @panic("test failure"); + expect(v[48] == 10) catch @panic("test failure"); + expect(v[49] == 11) catch @panic("test failure"); + expect(v[50] == 12) catch @panic("test failure"); + expect(v[51] == 13) catch @panic("test failure"); + expect(v[52] == 14) catch @panic("test failure"); + expect(v[53] == 15) catch @panic("test failure"); + expect(v[54] == 16) catch @panic("test failure"); + expect(v[55] == 17) catch @panic("test failure"); + expect(v[56] == 18) catch @panic("test failure"); + expect(v[57] == 19) catch @panic("test failure"); + expect(v[58] == 20) catch @panic("test failure"); + expect(v[59] == 21) catch @panic("test failure"); + expect(v[60] == 22) catch @panic("test failure"); + expect(v[61] == 23) catch @panic("test failure"); + expect(v[62] == 24) catch @panic("test failure"); + expect(v[63] == 25) catch @panic("test failure"); + expect(v[64] == 26) catch @panic("test failure"); + expect(v[65] == 27) catch @panic("test failure"); + expect(v[66] == 28) catch @panic("test failure"); + expect(v[67] == 29) catch @panic("test failure"); + expect(v[68] == 30) catch @panic("test failure"); + expect(v[69] == 31) catch @panic("test failure"); + expect(v[70] == 32) catch @panic("test failure"); + expect(v[71] == 33) catch @panic("test failure"); + expect(v[72] == 34) catch @panic("test failure"); + expect(v[73] == 35) catch @panic("test failure"); + expect(v[74] == 36) catch @panic("test failure"); + expect(v[75] == 37) catch @panic("test failure"); + expect(v[76] == 38) catch @panic("test failure"); + expect(v[77] == 39) catch @panic("test failure"); + expect(v[78] == 40) catch @panic("test failure"); + expect(v[79] == 41) catch @panic("test failure"); + expect(v[80] == 42) catch @panic("test failure"); + expect(v[81] == 43) catch @panic("test failure"); + expect(v[82] == 44) catch @panic("test failure"); + expect(v[83] == 45) catch @panic("test failure"); + expect(v[84] == 46) catch @panic("test failure"); + expect(v[85] == 47) catch @panic("test failure"); + expect(v[86] == 48) catch @panic("test failure"); + expect(v[87] == 49) catch @panic("test failure"); + expect(v[88] == 50) catch @panic("test failure"); + expect(v[89] == 51) catch @panic("test failure"); + expect(v[90] == 52) catch @panic("test failure"); + expect(v[91] == 53) catch @panic("test failure"); + expect(v[92] == 54) catch @panic("test failure"); + expect(v[93] == 55) catch @panic("test failure"); + expect(v[94] == 56) catch @panic("test failure"); + expect(v[95] == 57) catch @panic("test failure"); + expect(v[96] == 58) catch @panic("test failure"); + expect(v[97] == 59) catch @panic("test failure"); + expect(v[98] == 60) catch @panic("test failure"); + expect(v[99] == 61) catch @panic("test failure"); + expect(v[100] == 62) catch @panic("test failure"); + expect(v[101] == 63) catch @panic("test failure"); + expect(v[102] == 64) catch @panic("test failure"); + expect(v[103] == 65) catch @panic("test failure"); + expect(v[104] == 66) catch @panic("test failure"); + expect(v[105] == 67) catch @panic("test failure"); + expect(v[106] == 68) catch @panic("test failure"); + expect(v[107] == 69) catch @panic("test failure"); + expect(v[108] == 70) catch @panic("test failure"); + expect(v[109] == 71) catch @panic("test failure"); + expect(v[110] == 72) catch @panic("test failure"); + expect(v[111] == 73) catch @panic("test failure"); + expect(v[112] == 74) catch @panic("test failure"); + expect(v[113] == 75) catch @panic("test failure"); + expect(v[114] == 76) catch @panic("test failure"); + expect(v[115] == 77) catch @panic("test failure"); + expect(v[116] == 78) catch @panic("test failure"); + expect(v[117] == 79) catch @panic("test failure"); + expect(v[118] == 80) catch @panic("test failure"); + expect(v[119] == 81) catch @panic("test failure"); + expect(v[120] == 82) catch @panic("test failure"); + expect(v[121] == 83) catch @panic("test failure"); + expect(v[122] == 84) catch @panic("test failure"); + expect(v[123] == 85) catch @panic("test failure"); + expect(v[124] == 86) catch @panic("test failure"); + expect(v[125] == 87) catch @panic("test failure"); + expect(v[126] == 88) catch @panic("test failure"); + expect(v[127] == 89) catch @panic("test failure"); + expect(v[128] == 90) catch @panic("test failure"); + expect(v[129] == 91) catch @panic("test failure"); + expect(v[130] == 92) catch @panic("test failure"); + expect(v[131] == 93) catch @panic("test failure"); + expect(v[132] == 94) catch @panic("test failure"); + expect(v[133] == 95) catch @panic("test failure"); + expect(v[134] == 96) catch @panic("test failure"); + expect(v[135] == 97) catch @panic("test failure"); + expect(v[136] == 98) catch @panic("test failure"); + expect(v[137] == 99) catch @panic("test failure"); + expect(v[138] == 0) catch @panic("test failure"); + expect(v[139] == 1) catch @panic("test failure"); + expect(v[140] == 2) catch @panic("test failure"); + expect(v[141] == 3) catch @panic("test failure"); + expect(v[142] == 4) catch @panic("test failure"); + expect(v[143] == 5) catch @panic("test failure"); + expect(v[144] == 6) catch @panic("test failure"); + expect(v[145] == 7) catch @panic("test failure"); + expect(v[146] == 8) catch @panic("test failure"); + expect(v[147] == 9) catch @panic("test failure"); + expect(v[148] == 10) catch @panic("test failure"); + expect(v[149] == 11) catch @panic("test failure"); + expect(v[150] == 12) catch @panic("test failure"); + expect(v[151] == 13) catch @panic("test failure"); + expect(v[152] == 14) catch @panic("test failure"); + expect(v[153] == 15) catch @panic("test failure"); + expect(v[154] == 16) catch @panic("test failure"); + expect(v[155] == 17) catch @panic("test failure"); + expect(v[156] == 18) catch @panic("test failure"); + expect(v[157] == 19) catch @panic("test failure"); + expect(v[158] == 20) catch @panic("test failure"); + expect(v[159] == 21) catch @panic("test failure"); + expect(v[160] == 22) catch @panic("test failure"); + expect(v[161] == 23) catch @panic("test failure"); + expect(v[162] == 24) catch @panic("test failure"); + expect(v[163] == 25) catch @panic("test failure"); + expect(v[164] == 26) catch @panic("test failure"); + expect(v[165] == 27) catch @panic("test failure"); + expect(v[166] == 28) catch @panic("test failure"); + expect(v[167] == 29) catch @panic("test failure"); + expect(v[168] == 30) catch @panic("test failure"); + expect(v[169] == 31) catch @panic("test failure"); + expect(v[170] == 32) catch @panic("test failure"); + expect(v[171] == 33) catch @panic("test failure"); + expect(v[172] == 34) catch @panic("test failure"); + expect(v[173] == 35) catch @panic("test failure"); + expect(v[174] == 36) catch @panic("test failure"); + expect(v[175] == 37) catch @panic("test failure"); + expect(v[176] == 38) catch @panic("test failure"); + expect(v[177] == 39) catch @panic("test failure"); + expect(v[178] == 40) catch @panic("test failure"); + expect(v[179] == 41) catch @panic("test failure"); + expect(v[180] == 42) catch @panic("test failure"); + expect(v[181] == 43) catch @panic("test failure"); + expect(v[182] == 44) catch @panic("test failure"); + expect(v[183] == 45) catch @panic("test failure"); + expect(v[184] == 46) catch @panic("test failure"); + expect(v[185] == 47) catch @panic("test failure"); + expect(v[186] == 48) catch @panic("test failure"); + expect(v[187] == 49) catch @panic("test failure"); + expect(v[188] == 50) catch @panic("test failure"); + expect(v[189] == 51) catch @panic("test failure"); + expect(v[190] == 52) catch @panic("test failure"); + expect(v[191] == 53) catch @panic("test failure"); + expect(v[192] == 54) catch @panic("test failure"); + expect(v[193] == 55) catch @panic("test failure"); + expect(v[194] == 56) catch @panic("test failure"); + expect(v[195] == 57) catch @panic("test failure"); + expect(v[196] == 58) catch @panic("test failure"); + expect(v[197] == 59) catch @panic("test failure"); + expect(v[198] == 60) catch @panic("test failure"); + expect(v[199] == 61) catch @panic("test failure"); + expect(v[200] == 62) catch @panic("test failure"); + expect(v[201] == 63) catch @panic("test failure"); + expect(v[202] == 64) catch @panic("test failure"); + expect(v[203] == 65) catch @panic("test failure"); + expect(v[204] == 66) catch @panic("test failure"); + expect(v[205] == 67) catch @panic("test failure"); + expect(v[206] == 68) catch @panic("test failure"); + expect(v[207] == 69) catch @panic("test failure"); + expect(v[208] == 70) catch @panic("test failure"); + expect(v[209] == 71) catch @panic("test failure"); + expect(v[210] == 72) catch @panic("test failure"); + expect(v[211] == 73) catch @panic("test failure"); + expect(v[212] == 74) catch @panic("test failure"); + expect(v[213] == 75) catch @panic("test failure"); + expect(v[214] == 76) catch @panic("test failure"); + expect(v[215] == 77) catch @panic("test failure"); + expect(v[216] == 78) catch @panic("test failure"); + expect(v[217] == 79) catch @panic("test failure"); + expect(v[218] == 80) catch @panic("test failure"); + expect(v[219] == 81) catch @panic("test failure"); + expect(v[220] == 82) catch @panic("test failure"); + expect(v[221] == 83) catch @panic("test failure"); + expect(v[222] == 84) catch @panic("test failure"); + expect(v[223] == 85) catch @panic("test failure"); + expect(v[224] == 86) catch @panic("test failure"); + expect(v[225] == 87) catch @panic("test failure"); + expect(v[226] == 88) catch @panic("test failure"); + expect(v[227] == 89) catch @panic("test failure"); + expect(v[228] == 90) catch @panic("test failure"); + expect(v[229] == 91) catch @panic("test failure"); + expect(v[230] == 92) catch @panic("test failure"); + expect(v[231] == 93) catch @panic("test failure"); + expect(v[232] == 94) catch @panic("test failure"); + expect(v[233] == 95) catch @panic("test failure"); + expect(v[234] == 96) catch @panic("test failure"); + expect(v[235] == 97) catch @panic("test failure"); + expect(v[236] == 98) catch @panic("test failure"); + expect(v[237] == 99) catch @panic("test failure"); + expect(v[238] == 0) catch @panic("test failure"); + expect(v[239] == 1) catch @panic("test failure"); + expect(v[240] == 2) catch @panic("test failure"); + expect(v[241] == 3) catch @panic("test failure"); + expect(v[242] == 4) catch @panic("test failure"); + expect(v[243] == 5) catch @panic("test failure"); + expect(v[244] == 6) catch @panic("test failure"); + expect(v[245] == 7) catch @panic("test failure"); + expect(v[246] == 8) catch @panic("test failure"); + expect(v[247] == 9) catch @panic("test failure"); + expect(v[248] == 10) catch @panic("test failure"); + expect(v[249] == 11) catch @panic("test failure"); + expect(v[250] == 12) catch @panic("test failure"); + expect(v[251] == 13) catch @panic("test failure"); + expect(v[252] == 14) catch @panic("test failure"); + expect(v[253] == 15) catch @panic("test failure"); + expect(v[254] == 16) catch @panic("test failure"); + expect(v[255] == 17) catch @panic("test failure"); + expect(v[256] == 18) catch @panic("test failure"); + expect(v[257] == 19) catch @panic("test failure"); + expect(v[258] == 20) catch @panic("test failure"); + expect(v[259] == 21) catch @panic("test failure"); + expect(v[260] == 22) catch @panic("test failure"); + expect(v[261] == 23) catch @panic("test failure"); + expect(v[262] == 24) catch @panic("test failure"); + expect(v[263] == 25) catch @panic("test failure"); + expect(v[264] == 26) catch @panic("test failure"); + expect(v[265] == 27) catch @panic("test failure"); + expect(v[266] == 28) catch @panic("test failure"); + expect(v[267] == 29) catch @panic("test failure"); + expect(v[268] == 30) catch @panic("test failure"); + expect(v[269] == 31) catch @panic("test failure"); + expect(v[270] == 32) catch @panic("test failure"); + expect(v[271] == 33) catch @panic("test failure"); + expect(v[272] == 34) catch @panic("test failure"); + expect(v[273] == 35) catch @panic("test failure"); + expect(v[274] == 36) catch @panic("test failure"); + expect(v[275] == 37) catch @panic("test failure"); + expect(v[276] == 38) catch @panic("test failure"); + expect(v[277] == 39) catch @panic("test failure"); + expect(v[278] == 40) catch @panic("test failure"); + expect(v[279] == 41) catch @panic("test failure"); + expect(v[280] == 42) catch @panic("test failure"); + expect(v[281] == 43) catch @panic("test failure"); + expect(v[282] == 44) catch @panic("test failure"); + expect(v[283] == 45) catch @panic("test failure"); + expect(v[284] == 46) catch @panic("test failure"); + expect(v[285] == 47) catch @panic("test failure"); + expect(v[286] == 48) catch @panic("test failure"); + expect(v[287] == 49) catch @panic("test failure"); + expect(v[288] == 50) catch @panic("test failure"); + expect(v[289] == 51) catch @panic("test failure"); + expect(v[290] == 52) catch @panic("test failure"); + expect(v[291] == 53) catch @panic("test failure"); + expect(v[292] == 54) catch @panic("test failure"); + expect(v[293] == 55) catch @panic("test failure"); + expect(v[294] == 56) catch @panic("test failure"); + expect(v[295] == 57) catch @panic("test failure"); + expect(v[296] == 58) catch @panic("test failure"); + expect(v[297] == 59) catch @panic("test failure"); + expect(v[298] == 60) catch @panic("test failure"); + expect(v[299] == 61) catch @panic("test failure"); + expect(v[300] == 62) catch @panic("test failure"); + expect(v[301] == 63) catch @panic("test failure"); + expect(v[302] == 64) catch @panic("test failure"); + expect(v[303] == 65) catch @panic("test failure"); + expect(v[304] == 66) catch @panic("test failure"); + expect(v[305] == 67) catch @panic("test failure"); + expect(v[306] == 68) catch @panic("test failure"); + expect(v[307] == 69) catch @panic("test failure"); + expect(v[308] == 70) catch @panic("test failure"); + expect(v[309] == 71) catch @panic("test failure"); + expect(v[310] == 72) catch @panic("test failure"); + expect(v[311] == 73) catch @panic("test failure"); + expect(v[312] == 74) catch @panic("test failure"); + expect(v[313] == 75) catch @panic("test failure"); + expect(v[314] == 76) catch @panic("test failure"); + expect(v[315] == 77) catch @panic("test failure"); + expect(v[316] == 78) catch @panic("test failure"); + expect(v[317] == 79) catch @panic("test failure"); + expect(v[318] == 80) catch @panic("test failure"); + expect(v[319] == 81) catch @panic("test failure"); + expect(v[320] == 82) catch @panic("test failure"); + expect(v[321] == 83) catch @panic("test failure"); + expect(v[322] == 84) catch @panic("test failure"); + expect(v[323] == 85) catch @panic("test failure"); + expect(v[324] == 86) catch @panic("test failure"); + expect(v[325] == 87) catch @panic("test failure"); + expect(v[326] == 88) catch @panic("test failure"); + expect(v[327] == 89) catch @panic("test failure"); + expect(v[328] == 90) catch @panic("test failure"); + expect(v[329] == 91) catch @panic("test failure"); + expect(v[330] == 92) catch @panic("test failure"); + expect(v[331] == 93) catch @panic("test failure"); + expect(v[332] == 94) catch @panic("test failure"); + expect(v[333] == 95) catch @panic("test failure"); + expect(v[334] == 96) catch @panic("test failure"); + expect(v[335] == 97) catch @panic("test failure"); + expect(v[336] == 98) catch @panic("test failure"); + expect(v[337] == 99) catch @panic("test failure"); + expect(v[338] == 0) catch @panic("test failure"); + expect(v[339] == 1) catch @panic("test failure"); + expect(v[340] == 2) catch @panic("test failure"); + expect(v[341] == 3) catch @panic("test failure"); + expect(v[342] == 4) catch @panic("test failure"); + expect(v[343] == 5) catch @panic("test failure"); + expect(v[344] == 6) catch @panic("test failure"); + expect(v[345] == 7) catch @panic("test failure"); + expect(v[346] == 8) catch @panic("test failure"); + expect(v[347] == 9) catch @panic("test failure"); + expect(v[348] == 10) catch @panic("test failure"); + expect(v[349] == 11) catch @panic("test failure"); + expect(v[350] == 12) catch @panic("test failure"); + expect(v[351] == 13) catch @panic("test failure"); + expect(v[352] == 14) catch @panic("test failure"); + expect(v[353] == 15) catch @panic("test failure"); + expect(v[354] == 16) catch @panic("test failure"); + expect(v[355] == 17) catch @panic("test failure"); + expect(v[356] == 18) catch @panic("test failure"); + expect(v[357] == 19) catch @panic("test failure"); + expect(v[358] == 20) catch @panic("test failure"); + expect(v[359] == 21) catch @panic("test failure"); + expect(v[360] == 22) catch @panic("test failure"); + expect(v[361] == 23) catch @panic("test failure"); + expect(v[362] == 24) catch @panic("test failure"); + expect(v[363] == 25) catch @panic("test failure"); + expect(v[364] == 26) catch @panic("test failure"); + expect(v[365] == 27) catch @panic("test failure"); + expect(v[366] == 28) catch @panic("test failure"); + expect(v[367] == 29) catch @panic("test failure"); + expect(v[368] == 30) catch @panic("test failure"); + expect(v[369] == 31) catch @panic("test failure"); + expect(v[370] == 32) catch @panic("test failure"); + expect(v[371] == 33) catch @panic("test failure"); + expect(v[372] == 34) catch @panic("test failure"); + expect(v[373] == 35) catch @panic("test failure"); + expect(v[374] == 36) catch @panic("test failure"); + expect(v[375] == 37) catch @panic("test failure"); + expect(v[376] == 38) catch @panic("test failure"); + expect(v[377] == 39) catch @panic("test failure"); + expect(v[378] == 40) catch @panic("test failure"); + expect(v[379] == 41) catch @panic("test failure"); + expect(v[380] == 42) catch @panic("test failure"); + expect(v[381] == 43) catch @panic("test failure"); + expect(v[382] == 44) catch @panic("test failure"); + expect(v[383] == 45) catch @panic("test failure"); + expect(i == 384) catch @panic("test failure"); +} + +extern fn c_ret_vector_384_u8() @Vector(384, u8); +extern fn c_vector_384_u8(@Vector(384, u8), usize) void; +extern fn c_test_vector_384_u8() void; + +test "@Vector(384, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_384_u8(); + try expect(v[0] == 46); + try expect(v[1] == 47); + try expect(v[2] == 48); + try expect(v[3] == 49); + try expect(v[4] == 50); + try expect(v[5] == 51); + try expect(v[6] == 52); + try expect(v[7] == 53); + try expect(v[8] == 54); + try expect(v[9] == 55); + try expect(v[10] == 56); + try expect(v[11] == 57); + try expect(v[12] == 58); + try expect(v[13] == 59); + try expect(v[14] == 60); + try expect(v[15] == 61); + try expect(v[16] == 62); + try expect(v[17] == 63); + try expect(v[18] == 64); + try expect(v[19] == 65); + try expect(v[20] == 66); + try expect(v[21] == 67); + try expect(v[22] == 68); + try expect(v[23] == 69); + try expect(v[24] == 70); + try expect(v[25] == 71); + try expect(v[26] == 72); + try expect(v[27] == 73); + try expect(v[28] == 74); + try expect(v[29] == 75); + try expect(v[30] == 76); + try expect(v[31] == 77); + try expect(v[32] == 78); + try expect(v[33] == 79); + try expect(v[34] == 80); + try expect(v[35] == 81); + try expect(v[36] == 82); + try expect(v[37] == 83); + try expect(v[38] == 84); + try expect(v[39] == 85); + try expect(v[40] == 86); + try expect(v[41] == 87); + try expect(v[42] == 88); + try expect(v[43] == 89); + try expect(v[44] == 90); + try expect(v[45] == 91); + try expect(v[46] == 92); + try expect(v[47] == 93); + try expect(v[48] == 94); + try expect(v[49] == 95); + try expect(v[50] == 96); + try expect(v[51] == 97); + try expect(v[52] == 98); + try expect(v[53] == 99); + try expect(v[54] == 0); + try expect(v[55] == 1); + try expect(v[56] == 2); + try expect(v[57] == 3); + try expect(v[58] == 4); + try expect(v[59] == 5); + try expect(v[60] == 6); + try expect(v[61] == 7); + try expect(v[62] == 8); + try expect(v[63] == 9); + try expect(v[64] == 10); + try expect(v[65] == 11); + try expect(v[66] == 12); + try expect(v[67] == 13); + try expect(v[68] == 14); + try expect(v[69] == 15); + try expect(v[70] == 16); + try expect(v[71] == 17); + try expect(v[72] == 18); + try expect(v[73] == 19); + try expect(v[74] == 20); + try expect(v[75] == 21); + try expect(v[76] == 22); + try expect(v[77] == 23); + try expect(v[78] == 24); + try expect(v[79] == 25); + try expect(v[80] == 26); + try expect(v[81] == 27); + try expect(v[82] == 28); + try expect(v[83] == 29); + try expect(v[84] == 30); + try expect(v[85] == 31); + try expect(v[86] == 32); + try expect(v[87] == 33); + try expect(v[88] == 34); + try expect(v[89] == 35); + try expect(v[90] == 36); + try expect(v[91] == 37); + try expect(v[92] == 38); + try expect(v[93] == 39); + try expect(v[94] == 40); + try expect(v[95] == 41); + try expect(v[96] == 42); + try expect(v[97] == 43); + try expect(v[98] == 44); + try expect(v[99] == 45); + try expect(v[100] == 46); + try expect(v[101] == 47); + try expect(v[102] == 48); + try expect(v[103] == 49); + try expect(v[104] == 50); + try expect(v[105] == 51); + try expect(v[106] == 52); + try expect(v[107] == 53); + try expect(v[108] == 54); + try expect(v[109] == 55); + try expect(v[110] == 56); + try expect(v[111] == 57); + try expect(v[112] == 58); + try expect(v[113] == 59); + try expect(v[114] == 60); + try expect(v[115] == 61); + try expect(v[116] == 62); + try expect(v[117] == 63); + try expect(v[118] == 64); + try expect(v[119] == 65); + try expect(v[120] == 66); + try expect(v[121] == 67); + try expect(v[122] == 68); + try expect(v[123] == 69); + try expect(v[124] == 70); + try expect(v[125] == 71); + try expect(v[126] == 72); + try expect(v[127] == 73); + try expect(v[128] == 74); + try expect(v[129] == 75); + try expect(v[130] == 76); + try expect(v[131] == 77); + try expect(v[132] == 78); + try expect(v[133] == 79); + try expect(v[134] == 80); + try expect(v[135] == 81); + try expect(v[136] == 82); + try expect(v[137] == 83); + try expect(v[138] == 84); + try expect(v[139] == 85); + try expect(v[140] == 86); + try expect(v[141] == 87); + try expect(v[142] == 88); + try expect(v[143] == 89); + try expect(v[144] == 90); + try expect(v[145] == 91); + try expect(v[146] == 92); + try expect(v[147] == 93); + try expect(v[148] == 94); + try expect(v[149] == 95); + try expect(v[150] == 96); + try expect(v[151] == 97); + try expect(v[152] == 98); + try expect(v[153] == 99); + try expect(v[154] == 0); + try expect(v[155] == 1); + try expect(v[156] == 2); + try expect(v[157] == 3); + try expect(v[158] == 4); + try expect(v[159] == 5); + try expect(v[160] == 6); + try expect(v[161] == 7); + try expect(v[162] == 8); + try expect(v[163] == 9); + try expect(v[164] == 10); + try expect(v[165] == 11); + try expect(v[166] == 12); + try expect(v[167] == 13); + try expect(v[168] == 14); + try expect(v[169] == 15); + try expect(v[170] == 16); + try expect(v[171] == 17); + try expect(v[172] == 18); + try expect(v[173] == 19); + try expect(v[174] == 20); + try expect(v[175] == 21); + try expect(v[176] == 22); + try expect(v[177] == 23); + try expect(v[178] == 24); + try expect(v[179] == 25); + try expect(v[180] == 26); + try expect(v[181] == 27); + try expect(v[182] == 28); + try expect(v[183] == 29); + try expect(v[184] == 30); + try expect(v[185] == 31); + try expect(v[186] == 32); + try expect(v[187] == 33); + try expect(v[188] == 34); + try expect(v[189] == 35); + try expect(v[190] == 36); + try expect(v[191] == 37); + try expect(v[192] == 38); + try expect(v[193] == 39); + try expect(v[194] == 40); + try expect(v[195] == 41); + try expect(v[196] == 42); + try expect(v[197] == 43); + try expect(v[198] == 44); + try expect(v[199] == 45); + try expect(v[200] == 46); + try expect(v[201] == 47); + try expect(v[202] == 48); + try expect(v[203] == 49); + try expect(v[204] == 50); + try expect(v[205] == 51); + try expect(v[206] == 52); + try expect(v[207] == 53); + try expect(v[208] == 54); + try expect(v[209] == 55); + try expect(v[210] == 56); + try expect(v[211] == 57); + try expect(v[212] == 58); + try expect(v[213] == 59); + try expect(v[214] == 60); + try expect(v[215] == 61); + try expect(v[216] == 62); + try expect(v[217] == 63); + try expect(v[218] == 64); + try expect(v[219] == 65); + try expect(v[220] == 66); + try expect(v[221] == 67); + try expect(v[222] == 68); + try expect(v[223] == 69); + try expect(v[224] == 70); + try expect(v[225] == 71); + try expect(v[226] == 72); + try expect(v[227] == 73); + try expect(v[228] == 74); + try expect(v[229] == 75); + try expect(v[230] == 76); + try expect(v[231] == 77); + try expect(v[232] == 78); + try expect(v[233] == 79); + try expect(v[234] == 80); + try expect(v[235] == 81); + try expect(v[236] == 82); + try expect(v[237] == 83); + try expect(v[238] == 84); + try expect(v[239] == 85); + try expect(v[240] == 86); + try expect(v[241] == 87); + try expect(v[242] == 88); + try expect(v[243] == 89); + try expect(v[244] == 90); + try expect(v[245] == 91); + try expect(v[246] == 92); + try expect(v[247] == 93); + try expect(v[248] == 94); + try expect(v[249] == 95); + try expect(v[250] == 96); + try expect(v[251] == 97); + try expect(v[252] == 98); + try expect(v[253] == 99); + try expect(v[254] == 0); + try expect(v[255] == 1); + try expect(v[256] == 2); + try expect(v[257] == 3); + try expect(v[258] == 4); + try expect(v[259] == 5); + try expect(v[260] == 6); + try expect(v[261] == 7); + try expect(v[262] == 8); + try expect(v[263] == 9); + try expect(v[264] == 10); + try expect(v[265] == 11); + try expect(v[266] == 12); + try expect(v[267] == 13); + try expect(v[268] == 14); + try expect(v[269] == 15); + try expect(v[270] == 16); + try expect(v[271] == 17); + try expect(v[272] == 18); + try expect(v[273] == 19); + try expect(v[274] == 20); + try expect(v[275] == 21); + try expect(v[276] == 22); + try expect(v[277] == 23); + try expect(v[278] == 24); + try expect(v[279] == 25); + try expect(v[280] == 26); + try expect(v[281] == 27); + try expect(v[282] == 28); + try expect(v[283] == 29); + try expect(v[284] == 30); + try expect(v[285] == 31); + try expect(v[286] == 32); + try expect(v[287] == 33); + try expect(v[288] == 34); + try expect(v[289] == 35); + try expect(v[290] == 36); + try expect(v[291] == 37); + try expect(v[292] == 38); + try expect(v[293] == 39); + try expect(v[294] == 40); + try expect(v[295] == 41); + try expect(v[296] == 42); + try expect(v[297] == 43); + try expect(v[298] == 44); + try expect(v[299] == 45); + try expect(v[300] == 46); + try expect(v[301] == 47); + try expect(v[302] == 48); + try expect(v[303] == 49); + try expect(v[304] == 50); + try expect(v[305] == 51); + try expect(v[306] == 52); + try expect(v[307] == 53); + try expect(v[308] == 54); + try expect(v[309] == 55); + try expect(v[310] == 56); + try expect(v[311] == 57); + try expect(v[312] == 58); + try expect(v[313] == 59); + try expect(v[314] == 60); + try expect(v[315] == 61); + try expect(v[316] == 62); + try expect(v[317] == 63); + try expect(v[318] == 64); + try expect(v[319] == 65); + try expect(v[320] == 66); + try expect(v[321] == 67); + try expect(v[322] == 68); + try expect(v[323] == 69); + try expect(v[324] == 70); + try expect(v[325] == 71); + try expect(v[326] == 72); + try expect(v[327] == 73); + try expect(v[328] == 74); + try expect(v[329] == 75); + try expect(v[330] == 76); + try expect(v[331] == 77); + try expect(v[332] == 78); + try expect(v[333] == 79); + try expect(v[334] == 80); + try expect(v[335] == 81); + try expect(v[336] == 82); + try expect(v[337] == 83); + try expect(v[338] == 84); + try expect(v[339] == 85); + try expect(v[340] == 86); + try expect(v[341] == 87); + try expect(v[342] == 88); + try expect(v[343] == 89); + try expect(v[344] == 90); + try expect(v[345] == 91); + try expect(v[346] == 92); + try expect(v[347] == 93); + try expect(v[348] == 94); + try expect(v[349] == 95); + try expect(v[350] == 96); + try expect(v[351] == 97); + try expect(v[352] == 98); + try expect(v[353] == 99); + try expect(v[354] == 0); + try expect(v[355] == 1); + try expect(v[356] == 2); + try expect(v[357] == 3); + try expect(v[358] == 4); + try expect(v[359] == 5); + try expect(v[360] == 6); + try expect(v[361] == 7); + try expect(v[362] == 8); + try expect(v[363] == 9); + try expect(v[364] == 10); + try expect(v[365] == 11); + try expect(v[366] == 12); + try expect(v[367] == 13); + try expect(v[368] == 14); + try expect(v[369] == 15); + try expect(v[370] == 16); + try expect(v[371] == 17); + try expect(v[372] == 18); + try expect(v[373] == 19); + try expect(v[374] == 20); + try expect(v[375] == 21); + try expect(v[376] == 22); + try expect(v[377] == 23); + try expect(v[378] == 24); + try expect(v[379] == 25); + try expect(v[380] == 26); + try expect(v[381] == 27); + try expect(v[382] == 28); + try expect(v[383] == 29); + c_vector_384_u8(.{ + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + }, 384); + c_test_vector_384_u8(); +} + +export fn zig_ret_vector_512_u8() @Vector(512, u8) { + return .{ + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + }; +} +export fn zig_vector_512_u8(v: @Vector(512, u8), i: usize) void { + expect(v[0] == 26) catch @panic("test failure"); + expect(v[1] == 27) catch @panic("test failure"); + expect(v[2] == 28) catch @panic("test failure"); + expect(v[3] == 29) catch @panic("test failure"); + expect(v[4] == 30) catch @panic("test failure"); + expect(v[5] == 31) catch @panic("test failure"); + expect(v[6] == 32) catch @panic("test failure"); + expect(v[7] == 33) catch @panic("test failure"); + expect(v[8] == 34) catch @panic("test failure"); + expect(v[9] == 35) catch @panic("test failure"); + expect(v[10] == 36) catch @panic("test failure"); + expect(v[11] == 37) catch @panic("test failure"); + expect(v[12] == 38) catch @panic("test failure"); + expect(v[13] == 39) catch @panic("test failure"); + expect(v[14] == 40) catch @panic("test failure"); + expect(v[15] == 41) catch @panic("test failure"); + expect(v[16] == 42) catch @panic("test failure"); + expect(v[17] == 43) catch @panic("test failure"); + expect(v[18] == 44) catch @panic("test failure"); + expect(v[19] == 45) catch @panic("test failure"); + expect(v[20] == 46) catch @panic("test failure"); + expect(v[21] == 47) catch @panic("test failure"); + expect(v[22] == 48) catch @panic("test failure"); + expect(v[23] == 49) catch @panic("test failure"); + expect(v[24] == 50) catch @panic("test failure"); + expect(v[25] == 51) catch @panic("test failure"); + expect(v[26] == 52) catch @panic("test failure"); + expect(v[27] == 53) catch @panic("test failure"); + expect(v[28] == 54) catch @panic("test failure"); + expect(v[29] == 55) catch @panic("test failure"); + expect(v[30] == 56) catch @panic("test failure"); + expect(v[31] == 57) catch @panic("test failure"); + expect(v[32] == 58) catch @panic("test failure"); + expect(v[33] == 59) catch @panic("test failure"); + expect(v[34] == 60) catch @panic("test failure"); + expect(v[35] == 61) catch @panic("test failure"); + expect(v[36] == 62) catch @panic("test failure"); + expect(v[37] == 63) catch @panic("test failure"); + expect(v[38] == 64) catch @panic("test failure"); + expect(v[39] == 65) catch @panic("test failure"); + expect(v[40] == 66) catch @panic("test failure"); + expect(v[41] == 67) catch @panic("test failure"); + expect(v[42] == 68) catch @panic("test failure"); + expect(v[43] == 69) catch @panic("test failure"); + expect(v[44] == 70) catch @panic("test failure"); + expect(v[45] == 71) catch @panic("test failure"); + expect(v[46] == 72) catch @panic("test failure"); + expect(v[47] == 73) catch @panic("test failure"); + expect(v[48] == 74) catch @panic("test failure"); + expect(v[49] == 75) catch @panic("test failure"); + expect(v[50] == 76) catch @panic("test failure"); + expect(v[51] == 77) catch @panic("test failure"); + expect(v[52] == 78) catch @panic("test failure"); + expect(v[53] == 79) catch @panic("test failure"); + expect(v[54] == 80) catch @panic("test failure"); + expect(v[55] == 81) catch @panic("test failure"); + expect(v[56] == 82) catch @panic("test failure"); + expect(v[57] == 83) catch @panic("test failure"); + expect(v[58] == 84) catch @panic("test failure"); + expect(v[59] == 85) catch @panic("test failure"); + expect(v[60] == 86) catch @panic("test failure"); + expect(v[61] == 87) catch @panic("test failure"); + expect(v[62] == 88) catch @panic("test failure"); + expect(v[63] == 89) catch @panic("test failure"); + expect(v[64] == 90) catch @panic("test failure"); + expect(v[65] == 91) catch @panic("test failure"); + expect(v[66] == 92) catch @panic("test failure"); + expect(v[67] == 93) catch @panic("test failure"); + expect(v[68] == 94) catch @panic("test failure"); + expect(v[69] == 95) catch @panic("test failure"); + expect(v[70] == 96) catch @panic("test failure"); + expect(v[71] == 97) catch @panic("test failure"); + expect(v[72] == 98) catch @panic("test failure"); + expect(v[73] == 99) catch @panic("test failure"); + expect(v[74] == 0) catch @panic("test failure"); + expect(v[75] == 1) catch @panic("test failure"); + expect(v[76] == 2) catch @panic("test failure"); + expect(v[77] == 3) catch @panic("test failure"); + expect(v[78] == 4) catch @panic("test failure"); + expect(v[79] == 5) catch @panic("test failure"); + expect(v[80] == 6) catch @panic("test failure"); + expect(v[81] == 7) catch @panic("test failure"); + expect(v[82] == 8) catch @panic("test failure"); + expect(v[83] == 9) catch @panic("test failure"); + expect(v[84] == 10) catch @panic("test failure"); + expect(v[85] == 11) catch @panic("test failure"); + expect(v[86] == 12) catch @panic("test failure"); + expect(v[87] == 13) catch @panic("test failure"); + expect(v[88] == 14) catch @panic("test failure"); + expect(v[89] == 15) catch @panic("test failure"); + expect(v[90] == 16) catch @panic("test failure"); + expect(v[91] == 17) catch @panic("test failure"); + expect(v[92] == 18) catch @panic("test failure"); + expect(v[93] == 19) catch @panic("test failure"); + expect(v[94] == 20) catch @panic("test failure"); + expect(v[95] == 21) catch @panic("test failure"); + expect(v[96] == 22) catch @panic("test failure"); + expect(v[97] == 23) catch @panic("test failure"); + expect(v[98] == 24) catch @panic("test failure"); + expect(v[99] == 25) catch @panic("test failure"); + expect(v[100] == 26) catch @panic("test failure"); + expect(v[101] == 27) catch @panic("test failure"); + expect(v[102] == 28) catch @panic("test failure"); + expect(v[103] == 29) catch @panic("test failure"); + expect(v[104] == 30) catch @panic("test failure"); + expect(v[105] == 31) catch @panic("test failure"); + expect(v[106] == 32) catch @panic("test failure"); + expect(v[107] == 33) catch @panic("test failure"); + expect(v[108] == 34) catch @panic("test failure"); + expect(v[109] == 35) catch @panic("test failure"); + expect(v[110] == 36) catch @panic("test failure"); + expect(v[111] == 37) catch @panic("test failure"); + expect(v[112] == 38) catch @panic("test failure"); + expect(v[113] == 39) catch @panic("test failure"); + expect(v[114] == 40) catch @panic("test failure"); + expect(v[115] == 41) catch @panic("test failure"); + expect(v[116] == 42) catch @panic("test failure"); + expect(v[117] == 43) catch @panic("test failure"); + expect(v[118] == 44) catch @panic("test failure"); + expect(v[119] == 45) catch @panic("test failure"); + expect(v[120] == 46) catch @panic("test failure"); + expect(v[121] == 47) catch @panic("test failure"); + expect(v[122] == 48) catch @panic("test failure"); + expect(v[123] == 49) catch @panic("test failure"); + expect(v[124] == 50) catch @panic("test failure"); + expect(v[125] == 51) catch @panic("test failure"); + expect(v[126] == 52) catch @panic("test failure"); + expect(v[127] == 53) catch @panic("test failure"); + expect(v[128] == 54) catch @panic("test failure"); + expect(v[129] == 55) catch @panic("test failure"); + expect(v[130] == 56) catch @panic("test failure"); + expect(v[131] == 57) catch @panic("test failure"); + expect(v[132] == 58) catch @panic("test failure"); + expect(v[133] == 59) catch @panic("test failure"); + expect(v[134] == 60) catch @panic("test failure"); + expect(v[135] == 61) catch @panic("test failure"); + expect(v[136] == 62) catch @panic("test failure"); + expect(v[137] == 63) catch @panic("test failure"); + expect(v[138] == 64) catch @panic("test failure"); + expect(v[139] == 65) catch @panic("test failure"); + expect(v[140] == 66) catch @panic("test failure"); + expect(v[141] == 67) catch @panic("test failure"); + expect(v[142] == 68) catch @panic("test failure"); + expect(v[143] == 69) catch @panic("test failure"); + expect(v[144] == 70) catch @panic("test failure"); + expect(v[145] == 71) catch @panic("test failure"); + expect(v[146] == 72) catch @panic("test failure"); + expect(v[147] == 73) catch @panic("test failure"); + expect(v[148] == 74) catch @panic("test failure"); + expect(v[149] == 75) catch @panic("test failure"); + expect(v[150] == 76) catch @panic("test failure"); + expect(v[151] == 77) catch @panic("test failure"); + expect(v[152] == 78) catch @panic("test failure"); + expect(v[153] == 79) catch @panic("test failure"); + expect(v[154] == 80) catch @panic("test failure"); + expect(v[155] == 81) catch @panic("test failure"); + expect(v[156] == 82) catch @panic("test failure"); + expect(v[157] == 83) catch @panic("test failure"); + expect(v[158] == 84) catch @panic("test failure"); + expect(v[159] == 85) catch @panic("test failure"); + expect(v[160] == 86) catch @panic("test failure"); + expect(v[161] == 87) catch @panic("test failure"); + expect(v[162] == 88) catch @panic("test failure"); + expect(v[163] == 89) catch @panic("test failure"); + expect(v[164] == 90) catch @panic("test failure"); + expect(v[165] == 91) catch @panic("test failure"); + expect(v[166] == 92) catch @panic("test failure"); + expect(v[167] == 93) catch @panic("test failure"); + expect(v[168] == 94) catch @panic("test failure"); + expect(v[169] == 95) catch @panic("test failure"); + expect(v[170] == 96) catch @panic("test failure"); + expect(v[171] == 97) catch @panic("test failure"); + expect(v[172] == 98) catch @panic("test failure"); + expect(v[173] == 99) catch @panic("test failure"); + expect(v[174] == 0) catch @panic("test failure"); + expect(v[175] == 1) catch @panic("test failure"); + expect(v[176] == 2) catch @panic("test failure"); + expect(v[177] == 3) catch @panic("test failure"); + expect(v[178] == 4) catch @panic("test failure"); + expect(v[179] == 5) catch @panic("test failure"); + expect(v[180] == 6) catch @panic("test failure"); + expect(v[181] == 7) catch @panic("test failure"); + expect(v[182] == 8) catch @panic("test failure"); + expect(v[183] == 9) catch @panic("test failure"); + expect(v[184] == 10) catch @panic("test failure"); + expect(v[185] == 11) catch @panic("test failure"); + expect(v[186] == 12) catch @panic("test failure"); + expect(v[187] == 13) catch @panic("test failure"); + expect(v[188] == 14) catch @panic("test failure"); + expect(v[189] == 15) catch @panic("test failure"); + expect(v[190] == 16) catch @panic("test failure"); + expect(v[191] == 17) catch @panic("test failure"); + expect(v[192] == 18) catch @panic("test failure"); + expect(v[193] == 19) catch @panic("test failure"); + expect(v[194] == 20) catch @panic("test failure"); + expect(v[195] == 21) catch @panic("test failure"); + expect(v[196] == 22) catch @panic("test failure"); + expect(v[197] == 23) catch @panic("test failure"); + expect(v[198] == 24) catch @panic("test failure"); + expect(v[199] == 25) catch @panic("test failure"); + expect(v[200] == 26) catch @panic("test failure"); + expect(v[201] == 27) catch @panic("test failure"); + expect(v[202] == 28) catch @panic("test failure"); + expect(v[203] == 29) catch @panic("test failure"); + expect(v[204] == 30) catch @panic("test failure"); + expect(v[205] == 31) catch @panic("test failure"); + expect(v[206] == 32) catch @panic("test failure"); + expect(v[207] == 33) catch @panic("test failure"); + expect(v[208] == 34) catch @panic("test failure"); + expect(v[209] == 35) catch @panic("test failure"); + expect(v[210] == 36) catch @panic("test failure"); + expect(v[211] == 37) catch @panic("test failure"); + expect(v[212] == 38) catch @panic("test failure"); + expect(v[213] == 39) catch @panic("test failure"); + expect(v[214] == 40) catch @panic("test failure"); + expect(v[215] == 41) catch @panic("test failure"); + expect(v[216] == 42) catch @panic("test failure"); + expect(v[217] == 43) catch @panic("test failure"); + expect(v[218] == 44) catch @panic("test failure"); + expect(v[219] == 45) catch @panic("test failure"); + expect(v[220] == 46) catch @panic("test failure"); + expect(v[221] == 47) catch @panic("test failure"); + expect(v[222] == 48) catch @panic("test failure"); + expect(v[223] == 49) catch @panic("test failure"); + expect(v[224] == 50) catch @panic("test failure"); + expect(v[225] == 51) catch @panic("test failure"); + expect(v[226] == 52) catch @panic("test failure"); + expect(v[227] == 53) catch @panic("test failure"); + expect(v[228] == 54) catch @panic("test failure"); + expect(v[229] == 55) catch @panic("test failure"); + expect(v[230] == 56) catch @panic("test failure"); + expect(v[231] == 57) catch @panic("test failure"); + expect(v[232] == 58) catch @panic("test failure"); + expect(v[233] == 59) catch @panic("test failure"); + expect(v[234] == 60) catch @panic("test failure"); + expect(v[235] == 61) catch @panic("test failure"); + expect(v[236] == 62) catch @panic("test failure"); + expect(v[237] == 63) catch @panic("test failure"); + expect(v[238] == 64) catch @panic("test failure"); + expect(v[239] == 65) catch @panic("test failure"); + expect(v[240] == 66) catch @panic("test failure"); + expect(v[241] == 67) catch @panic("test failure"); + expect(v[242] == 68) catch @panic("test failure"); + expect(v[243] == 69) catch @panic("test failure"); + expect(v[244] == 70) catch @panic("test failure"); + expect(v[245] == 71) catch @panic("test failure"); + expect(v[246] == 72) catch @panic("test failure"); + expect(v[247] == 73) catch @panic("test failure"); + expect(v[248] == 74) catch @panic("test failure"); + expect(v[249] == 75) catch @panic("test failure"); + expect(v[250] == 76) catch @panic("test failure"); + expect(v[251] == 77) catch @panic("test failure"); + expect(v[252] == 78) catch @panic("test failure"); + expect(v[253] == 79) catch @panic("test failure"); + expect(v[254] == 80) catch @panic("test failure"); + expect(v[255] == 81) catch @panic("test failure"); + expect(v[256] == 82) catch @panic("test failure"); + expect(v[257] == 83) catch @panic("test failure"); + expect(v[258] == 84) catch @panic("test failure"); + expect(v[259] == 85) catch @panic("test failure"); + expect(v[260] == 86) catch @panic("test failure"); + expect(v[261] == 87) catch @panic("test failure"); + expect(v[262] == 88) catch @panic("test failure"); + expect(v[263] == 89) catch @panic("test failure"); + expect(v[264] == 90) catch @panic("test failure"); + expect(v[265] == 91) catch @panic("test failure"); + expect(v[266] == 92) catch @panic("test failure"); + expect(v[267] == 93) catch @panic("test failure"); + expect(v[268] == 94) catch @panic("test failure"); + expect(v[269] == 95) catch @panic("test failure"); + expect(v[270] == 96) catch @panic("test failure"); + expect(v[271] == 97) catch @panic("test failure"); + expect(v[272] == 98) catch @panic("test failure"); + expect(v[273] == 99) catch @panic("test failure"); + expect(v[274] == 0) catch @panic("test failure"); + expect(v[275] == 1) catch @panic("test failure"); + expect(v[276] == 2) catch @panic("test failure"); + expect(v[277] == 3) catch @panic("test failure"); + expect(v[278] == 4) catch @panic("test failure"); + expect(v[279] == 5) catch @panic("test failure"); + expect(v[280] == 6) catch @panic("test failure"); + expect(v[281] == 7) catch @panic("test failure"); + expect(v[282] == 8) catch @panic("test failure"); + expect(v[283] == 9) catch @panic("test failure"); + expect(v[284] == 10) catch @panic("test failure"); + expect(v[285] == 11) catch @panic("test failure"); + expect(v[286] == 12) catch @panic("test failure"); + expect(v[287] == 13) catch @panic("test failure"); + expect(v[288] == 14) catch @panic("test failure"); + expect(v[289] == 15) catch @panic("test failure"); + expect(v[290] == 16) catch @panic("test failure"); + expect(v[291] == 17) catch @panic("test failure"); + expect(v[292] == 18) catch @panic("test failure"); + expect(v[293] == 19) catch @panic("test failure"); + expect(v[294] == 20) catch @panic("test failure"); + expect(v[295] == 21) catch @panic("test failure"); + expect(v[296] == 22) catch @panic("test failure"); + expect(v[297] == 23) catch @panic("test failure"); + expect(v[298] == 24) catch @panic("test failure"); + expect(v[299] == 25) catch @panic("test failure"); + expect(v[300] == 26) catch @panic("test failure"); + expect(v[301] == 27) catch @panic("test failure"); + expect(v[302] == 28) catch @panic("test failure"); + expect(v[303] == 29) catch @panic("test failure"); + expect(v[304] == 30) catch @panic("test failure"); + expect(v[305] == 31) catch @panic("test failure"); + expect(v[306] == 32) catch @panic("test failure"); + expect(v[307] == 33) catch @panic("test failure"); + expect(v[308] == 34) catch @panic("test failure"); + expect(v[309] == 35) catch @panic("test failure"); + expect(v[310] == 36) catch @panic("test failure"); + expect(v[311] == 37) catch @panic("test failure"); + expect(v[312] == 38) catch @panic("test failure"); + expect(v[313] == 39) catch @panic("test failure"); + expect(v[314] == 40) catch @panic("test failure"); + expect(v[315] == 41) catch @panic("test failure"); + expect(v[316] == 42) catch @panic("test failure"); + expect(v[317] == 43) catch @panic("test failure"); + expect(v[318] == 44) catch @panic("test failure"); + expect(v[319] == 45) catch @panic("test failure"); + expect(v[320] == 46) catch @panic("test failure"); + expect(v[321] == 47) catch @panic("test failure"); + expect(v[322] == 48) catch @panic("test failure"); + expect(v[323] == 49) catch @panic("test failure"); + expect(v[324] == 50) catch @panic("test failure"); + expect(v[325] == 51) catch @panic("test failure"); + expect(v[326] == 52) catch @panic("test failure"); + expect(v[327] == 53) catch @panic("test failure"); + expect(v[328] == 54) catch @panic("test failure"); + expect(v[329] == 55) catch @panic("test failure"); + expect(v[330] == 56) catch @panic("test failure"); + expect(v[331] == 57) catch @panic("test failure"); + expect(v[332] == 58) catch @panic("test failure"); + expect(v[333] == 59) catch @panic("test failure"); + expect(v[334] == 60) catch @panic("test failure"); + expect(v[335] == 61) catch @panic("test failure"); + expect(v[336] == 62) catch @panic("test failure"); + expect(v[337] == 63) catch @panic("test failure"); + expect(v[338] == 64) catch @panic("test failure"); + expect(v[339] == 65) catch @panic("test failure"); + expect(v[340] == 66) catch @panic("test failure"); + expect(v[341] == 67) catch @panic("test failure"); + expect(v[342] == 68) catch @panic("test failure"); + expect(v[343] == 69) catch @panic("test failure"); + expect(v[344] == 70) catch @panic("test failure"); + expect(v[345] == 71) catch @panic("test failure"); + expect(v[346] == 72) catch @panic("test failure"); + expect(v[347] == 73) catch @panic("test failure"); + expect(v[348] == 74) catch @panic("test failure"); + expect(v[349] == 75) catch @panic("test failure"); + expect(v[350] == 76) catch @panic("test failure"); + expect(v[351] == 77) catch @panic("test failure"); + expect(v[352] == 78) catch @panic("test failure"); + expect(v[353] == 79) catch @panic("test failure"); + expect(v[354] == 80) catch @panic("test failure"); + expect(v[355] == 81) catch @panic("test failure"); + expect(v[356] == 82) catch @panic("test failure"); + expect(v[357] == 83) catch @panic("test failure"); + expect(v[358] == 84) catch @panic("test failure"); + expect(v[359] == 85) catch @panic("test failure"); + expect(v[360] == 86) catch @panic("test failure"); + expect(v[361] == 87) catch @panic("test failure"); + expect(v[362] == 88) catch @panic("test failure"); + expect(v[363] == 89) catch @panic("test failure"); + expect(v[364] == 90) catch @panic("test failure"); + expect(v[365] == 91) catch @panic("test failure"); + expect(v[366] == 92) catch @panic("test failure"); + expect(v[367] == 93) catch @panic("test failure"); + expect(v[368] == 94) catch @panic("test failure"); + expect(v[369] == 95) catch @panic("test failure"); + expect(v[370] == 96) catch @panic("test failure"); + expect(v[371] == 97) catch @panic("test failure"); + expect(v[372] == 98) catch @panic("test failure"); + expect(v[373] == 99) catch @panic("test failure"); + expect(v[374] == 0) catch @panic("test failure"); + expect(v[375] == 1) catch @panic("test failure"); + expect(v[376] == 2) catch @panic("test failure"); + expect(v[377] == 3) catch @panic("test failure"); + expect(v[378] == 4) catch @panic("test failure"); + expect(v[379] == 5) catch @panic("test failure"); + expect(v[380] == 6) catch @panic("test failure"); + expect(v[381] == 7) catch @panic("test failure"); + expect(v[382] == 8) catch @panic("test failure"); + expect(v[383] == 9) catch @panic("test failure"); + expect(v[384] == 10) catch @panic("test failure"); + expect(v[385] == 11) catch @panic("test failure"); + expect(v[386] == 12) catch @panic("test failure"); + expect(v[387] == 13) catch @panic("test failure"); + expect(v[388] == 14) catch @panic("test failure"); + expect(v[389] == 15) catch @panic("test failure"); + expect(v[390] == 16) catch @panic("test failure"); + expect(v[391] == 17) catch @panic("test failure"); + expect(v[392] == 18) catch @panic("test failure"); + expect(v[393] == 19) catch @panic("test failure"); + expect(v[394] == 20) catch @panic("test failure"); + expect(v[395] == 21) catch @panic("test failure"); + expect(v[396] == 22) catch @panic("test failure"); + expect(v[397] == 23) catch @panic("test failure"); + expect(v[398] == 24) catch @panic("test failure"); + expect(v[399] == 25) catch @panic("test failure"); + expect(v[400] == 26) catch @panic("test failure"); + expect(v[401] == 27) catch @panic("test failure"); + expect(v[402] == 28) catch @panic("test failure"); + expect(v[403] == 29) catch @panic("test failure"); + expect(v[404] == 30) catch @panic("test failure"); + expect(v[405] == 31) catch @panic("test failure"); + expect(v[406] == 32) catch @panic("test failure"); + expect(v[407] == 33) catch @panic("test failure"); + expect(v[408] == 34) catch @panic("test failure"); + expect(v[409] == 35) catch @panic("test failure"); + expect(v[410] == 36) catch @panic("test failure"); + expect(v[411] == 37) catch @panic("test failure"); + expect(v[412] == 38) catch @panic("test failure"); + expect(v[413] == 39) catch @panic("test failure"); + expect(v[414] == 40) catch @panic("test failure"); + expect(v[415] == 41) catch @panic("test failure"); + expect(v[416] == 42) catch @panic("test failure"); + expect(v[417] == 43) catch @panic("test failure"); + expect(v[418] == 44) catch @panic("test failure"); + expect(v[419] == 45) catch @panic("test failure"); + expect(v[420] == 46) catch @panic("test failure"); + expect(v[421] == 47) catch @panic("test failure"); + expect(v[422] == 48) catch @panic("test failure"); + expect(v[423] == 49) catch @panic("test failure"); + expect(v[424] == 50) catch @panic("test failure"); + expect(v[425] == 51) catch @panic("test failure"); + expect(v[426] == 52) catch @panic("test failure"); + expect(v[427] == 53) catch @panic("test failure"); + expect(v[428] == 54) catch @panic("test failure"); + expect(v[429] == 55) catch @panic("test failure"); + expect(v[430] == 56) catch @panic("test failure"); + expect(v[431] == 57) catch @panic("test failure"); + expect(v[432] == 58) catch @panic("test failure"); + expect(v[433] == 59) catch @panic("test failure"); + expect(v[434] == 60) catch @panic("test failure"); + expect(v[435] == 61) catch @panic("test failure"); + expect(v[436] == 62) catch @panic("test failure"); + expect(v[437] == 63) catch @panic("test failure"); + expect(v[438] == 64) catch @panic("test failure"); + expect(v[439] == 65) catch @panic("test failure"); + expect(v[440] == 66) catch @panic("test failure"); + expect(v[441] == 67) catch @panic("test failure"); + expect(v[442] == 68) catch @panic("test failure"); + expect(v[443] == 69) catch @panic("test failure"); + expect(v[444] == 70) catch @panic("test failure"); + expect(v[445] == 71) catch @panic("test failure"); + expect(v[446] == 72) catch @panic("test failure"); + expect(v[447] == 73) catch @panic("test failure"); + expect(v[448] == 74) catch @panic("test failure"); + expect(v[449] == 75) catch @panic("test failure"); + expect(v[450] == 76) catch @panic("test failure"); + expect(v[451] == 77) catch @panic("test failure"); + expect(v[452] == 78) catch @panic("test failure"); + expect(v[453] == 79) catch @panic("test failure"); + expect(v[454] == 80) catch @panic("test failure"); + expect(v[455] == 81) catch @panic("test failure"); + expect(v[456] == 82) catch @panic("test failure"); + expect(v[457] == 83) catch @panic("test failure"); + expect(v[458] == 84) catch @panic("test failure"); + expect(v[459] == 85) catch @panic("test failure"); + expect(v[460] == 86) catch @panic("test failure"); + expect(v[461] == 87) catch @panic("test failure"); + expect(v[462] == 88) catch @panic("test failure"); + expect(v[463] == 89) catch @panic("test failure"); + expect(v[464] == 90) catch @panic("test failure"); + expect(v[465] == 91) catch @panic("test failure"); + expect(v[466] == 92) catch @panic("test failure"); + expect(v[467] == 93) catch @panic("test failure"); + expect(v[468] == 94) catch @panic("test failure"); + expect(v[469] == 95) catch @panic("test failure"); + expect(v[470] == 96) catch @panic("test failure"); + expect(v[471] == 97) catch @panic("test failure"); + expect(v[472] == 98) catch @panic("test failure"); + expect(v[473] == 99) catch @panic("test failure"); + expect(v[474] == 0) catch @panic("test failure"); + expect(v[475] == 1) catch @panic("test failure"); + expect(v[476] == 2) catch @panic("test failure"); + expect(v[477] == 3) catch @panic("test failure"); + expect(v[478] == 4) catch @panic("test failure"); + expect(v[479] == 5) catch @panic("test failure"); + expect(v[480] == 6) catch @panic("test failure"); + expect(v[481] == 7) catch @panic("test failure"); + expect(v[482] == 8) catch @panic("test failure"); + expect(v[483] == 9) catch @panic("test failure"); + expect(v[484] == 10) catch @panic("test failure"); + expect(v[485] == 11) catch @panic("test failure"); + expect(v[486] == 12) catch @panic("test failure"); + expect(v[487] == 13) catch @panic("test failure"); + expect(v[488] == 14) catch @panic("test failure"); + expect(v[489] == 15) catch @panic("test failure"); + expect(v[490] == 16) catch @panic("test failure"); + expect(v[491] == 17) catch @panic("test failure"); + expect(v[492] == 18) catch @panic("test failure"); + expect(v[493] == 19) catch @panic("test failure"); + expect(v[494] == 20) catch @panic("test failure"); + expect(v[495] == 21) catch @panic("test failure"); + expect(v[496] == 22) catch @panic("test failure"); + expect(v[497] == 23) catch @panic("test failure"); + expect(v[498] == 24) catch @panic("test failure"); + expect(v[499] == 25) catch @panic("test failure"); + expect(v[500] == 26) catch @panic("test failure"); + expect(v[501] == 27) catch @panic("test failure"); + expect(v[502] == 28) catch @panic("test failure"); + expect(v[503] == 29) catch @panic("test failure"); + expect(v[504] == 30) catch @panic("test failure"); + expect(v[505] == 31) catch @panic("test failure"); + expect(v[506] == 32) catch @panic("test failure"); + expect(v[507] == 33) catch @panic("test failure"); + expect(v[508] == 34) catch @panic("test failure"); + expect(v[509] == 35) catch @panic("test failure"); + expect(v[510] == 36) catch @panic("test failure"); + expect(v[511] == 37) catch @panic("test failure"); + expect(i == 512) catch @panic("test failure"); +} + +extern fn c_ret_vector_512_u8() @Vector(512, u8); +extern fn c_vector_512_u8(@Vector(512, u8), usize) void; +extern fn c_test_vector_512_u8() void; + +test "@Vector(512, u8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_512_u8(); + try expect(v[0] == 38); + try expect(v[1] == 39); + try expect(v[2] == 40); + try expect(v[3] == 41); + try expect(v[4] == 42); + try expect(v[5] == 43); + try expect(v[6] == 44); + try expect(v[7] == 45); + try expect(v[8] == 46); + try expect(v[9] == 47); + try expect(v[10] == 48); + try expect(v[11] == 49); + try expect(v[12] == 50); + try expect(v[13] == 51); + try expect(v[14] == 52); + try expect(v[15] == 53); + try expect(v[16] == 54); + try expect(v[17] == 55); + try expect(v[18] == 56); + try expect(v[19] == 57); + try expect(v[20] == 58); + try expect(v[21] == 59); + try expect(v[22] == 60); + try expect(v[23] == 61); + try expect(v[24] == 62); + try expect(v[25] == 63); + try expect(v[26] == 64); + try expect(v[27] == 65); + try expect(v[28] == 66); + try expect(v[29] == 67); + try expect(v[30] == 68); + try expect(v[31] == 69); + try expect(v[32] == 70); + try expect(v[33] == 71); + try expect(v[34] == 72); + try expect(v[35] == 73); + try expect(v[36] == 74); + try expect(v[37] == 75); + try expect(v[38] == 76); + try expect(v[39] == 77); + try expect(v[40] == 78); + try expect(v[41] == 79); + try expect(v[42] == 80); + try expect(v[43] == 81); + try expect(v[44] == 82); + try expect(v[45] == 83); + try expect(v[46] == 84); + try expect(v[47] == 85); + try expect(v[48] == 86); + try expect(v[49] == 87); + try expect(v[50] == 88); + try expect(v[51] == 89); + try expect(v[52] == 90); + try expect(v[53] == 91); + try expect(v[54] == 92); + try expect(v[55] == 93); + try expect(v[56] == 94); + try expect(v[57] == 95); + try expect(v[58] == 96); + try expect(v[59] == 97); + try expect(v[60] == 98); + try expect(v[61] == 99); + try expect(v[62] == 0); + try expect(v[63] == 1); + try expect(v[64] == 2); + try expect(v[65] == 3); + try expect(v[66] == 4); + try expect(v[67] == 5); + try expect(v[68] == 6); + try expect(v[69] == 7); + try expect(v[70] == 8); + try expect(v[71] == 9); + try expect(v[72] == 10); + try expect(v[73] == 11); + try expect(v[74] == 12); + try expect(v[75] == 13); + try expect(v[76] == 14); + try expect(v[77] == 15); + try expect(v[78] == 16); + try expect(v[79] == 17); + try expect(v[80] == 18); + try expect(v[81] == 19); + try expect(v[82] == 20); + try expect(v[83] == 21); + try expect(v[84] == 22); + try expect(v[85] == 23); + try expect(v[86] == 24); + try expect(v[87] == 25); + try expect(v[88] == 26); + try expect(v[89] == 27); + try expect(v[90] == 28); + try expect(v[91] == 29); + try expect(v[92] == 30); + try expect(v[93] == 31); + try expect(v[94] == 32); + try expect(v[95] == 33); + try expect(v[96] == 34); + try expect(v[97] == 35); + try expect(v[98] == 36); + try expect(v[99] == 37); + try expect(v[100] == 38); + try expect(v[101] == 39); + try expect(v[102] == 40); + try expect(v[103] == 41); + try expect(v[104] == 42); + try expect(v[105] == 43); + try expect(v[106] == 44); + try expect(v[107] == 45); + try expect(v[108] == 46); + try expect(v[109] == 47); + try expect(v[110] == 48); + try expect(v[111] == 49); + try expect(v[112] == 50); + try expect(v[113] == 51); + try expect(v[114] == 52); + try expect(v[115] == 53); + try expect(v[116] == 54); + try expect(v[117] == 55); + try expect(v[118] == 56); + try expect(v[119] == 57); + try expect(v[120] == 58); + try expect(v[121] == 59); + try expect(v[122] == 60); + try expect(v[123] == 61); + try expect(v[124] == 62); + try expect(v[125] == 63); + try expect(v[126] == 64); + try expect(v[127] == 65); + try expect(v[128] == 66); + try expect(v[129] == 67); + try expect(v[130] == 68); + try expect(v[131] == 69); + try expect(v[132] == 70); + try expect(v[133] == 71); + try expect(v[134] == 72); + try expect(v[135] == 73); + try expect(v[136] == 74); + try expect(v[137] == 75); + try expect(v[138] == 76); + try expect(v[139] == 77); + try expect(v[140] == 78); + try expect(v[141] == 79); + try expect(v[142] == 80); + try expect(v[143] == 81); + try expect(v[144] == 82); + try expect(v[145] == 83); + try expect(v[146] == 84); + try expect(v[147] == 85); + try expect(v[148] == 86); + try expect(v[149] == 87); + try expect(v[150] == 88); + try expect(v[151] == 89); + try expect(v[152] == 90); + try expect(v[153] == 91); + try expect(v[154] == 92); + try expect(v[155] == 93); + try expect(v[156] == 94); + try expect(v[157] == 95); + try expect(v[158] == 96); + try expect(v[159] == 97); + try expect(v[160] == 98); + try expect(v[161] == 99); + try expect(v[162] == 0); + try expect(v[163] == 1); + try expect(v[164] == 2); + try expect(v[165] == 3); + try expect(v[166] == 4); + try expect(v[167] == 5); + try expect(v[168] == 6); + try expect(v[169] == 7); + try expect(v[170] == 8); + try expect(v[171] == 9); + try expect(v[172] == 10); + try expect(v[173] == 11); + try expect(v[174] == 12); + try expect(v[175] == 13); + try expect(v[176] == 14); + try expect(v[177] == 15); + try expect(v[178] == 16); + try expect(v[179] == 17); + try expect(v[180] == 18); + try expect(v[181] == 19); + try expect(v[182] == 20); + try expect(v[183] == 21); + try expect(v[184] == 22); + try expect(v[185] == 23); + try expect(v[186] == 24); + try expect(v[187] == 25); + try expect(v[188] == 26); + try expect(v[189] == 27); + try expect(v[190] == 28); + try expect(v[191] == 29); + try expect(v[192] == 30); + try expect(v[193] == 31); + try expect(v[194] == 32); + try expect(v[195] == 33); + try expect(v[196] == 34); + try expect(v[197] == 35); + try expect(v[198] == 36); + try expect(v[199] == 37); + try expect(v[200] == 38); + try expect(v[201] == 39); + try expect(v[202] == 40); + try expect(v[203] == 41); + try expect(v[204] == 42); + try expect(v[205] == 43); + try expect(v[206] == 44); + try expect(v[207] == 45); + try expect(v[208] == 46); + try expect(v[209] == 47); + try expect(v[210] == 48); + try expect(v[211] == 49); + try expect(v[212] == 50); + try expect(v[213] == 51); + try expect(v[214] == 52); + try expect(v[215] == 53); + try expect(v[216] == 54); + try expect(v[217] == 55); + try expect(v[218] == 56); + try expect(v[219] == 57); + try expect(v[220] == 58); + try expect(v[221] == 59); + try expect(v[222] == 60); + try expect(v[223] == 61); + try expect(v[224] == 62); + try expect(v[225] == 63); + try expect(v[226] == 64); + try expect(v[227] == 65); + try expect(v[228] == 66); + try expect(v[229] == 67); + try expect(v[230] == 68); + try expect(v[231] == 69); + try expect(v[232] == 70); + try expect(v[233] == 71); + try expect(v[234] == 72); + try expect(v[235] == 73); + try expect(v[236] == 74); + try expect(v[237] == 75); + try expect(v[238] == 76); + try expect(v[239] == 77); + try expect(v[240] == 78); + try expect(v[241] == 79); + try expect(v[242] == 80); + try expect(v[243] == 81); + try expect(v[244] == 82); + try expect(v[245] == 83); + try expect(v[246] == 84); + try expect(v[247] == 85); + try expect(v[248] == 86); + try expect(v[249] == 87); + try expect(v[250] == 88); + try expect(v[251] == 89); + try expect(v[252] == 90); + try expect(v[253] == 91); + try expect(v[254] == 92); + try expect(v[255] == 93); + try expect(v[256] == 94); + try expect(v[257] == 95); + try expect(v[258] == 96); + try expect(v[259] == 97); + try expect(v[260] == 98); + try expect(v[261] == 99); + try expect(v[262] == 0); + try expect(v[263] == 1); + try expect(v[264] == 2); + try expect(v[265] == 3); + try expect(v[266] == 4); + try expect(v[267] == 5); + try expect(v[268] == 6); + try expect(v[269] == 7); + try expect(v[270] == 8); + try expect(v[271] == 9); + try expect(v[272] == 10); + try expect(v[273] == 11); + try expect(v[274] == 12); + try expect(v[275] == 13); + try expect(v[276] == 14); + try expect(v[277] == 15); + try expect(v[278] == 16); + try expect(v[279] == 17); + try expect(v[280] == 18); + try expect(v[281] == 19); + try expect(v[282] == 20); + try expect(v[283] == 21); + try expect(v[284] == 22); + try expect(v[285] == 23); + try expect(v[286] == 24); + try expect(v[287] == 25); + try expect(v[288] == 26); + try expect(v[289] == 27); + try expect(v[290] == 28); + try expect(v[291] == 29); + try expect(v[292] == 30); + try expect(v[293] == 31); + try expect(v[294] == 32); + try expect(v[295] == 33); + try expect(v[296] == 34); + try expect(v[297] == 35); + try expect(v[298] == 36); + try expect(v[299] == 37); + try expect(v[300] == 38); + try expect(v[301] == 39); + try expect(v[302] == 40); + try expect(v[303] == 41); + try expect(v[304] == 42); + try expect(v[305] == 43); + try expect(v[306] == 44); + try expect(v[307] == 45); + try expect(v[308] == 46); + try expect(v[309] == 47); + try expect(v[310] == 48); + try expect(v[311] == 49); + try expect(v[312] == 50); + try expect(v[313] == 51); + try expect(v[314] == 52); + try expect(v[315] == 53); + try expect(v[316] == 54); + try expect(v[317] == 55); + try expect(v[318] == 56); + try expect(v[319] == 57); + try expect(v[320] == 58); + try expect(v[321] == 59); + try expect(v[322] == 60); + try expect(v[323] == 61); + try expect(v[324] == 62); + try expect(v[325] == 63); + try expect(v[326] == 64); + try expect(v[327] == 65); + try expect(v[328] == 66); + try expect(v[329] == 67); + try expect(v[330] == 68); + try expect(v[331] == 69); + try expect(v[332] == 70); + try expect(v[333] == 71); + try expect(v[334] == 72); + try expect(v[335] == 73); + try expect(v[336] == 74); + try expect(v[337] == 75); + try expect(v[338] == 76); + try expect(v[339] == 77); + try expect(v[340] == 78); + try expect(v[341] == 79); + try expect(v[342] == 80); + try expect(v[343] == 81); + try expect(v[344] == 82); + try expect(v[345] == 83); + try expect(v[346] == 84); + try expect(v[347] == 85); + try expect(v[348] == 86); + try expect(v[349] == 87); + try expect(v[350] == 88); + try expect(v[351] == 89); + try expect(v[352] == 90); + try expect(v[353] == 91); + try expect(v[354] == 92); + try expect(v[355] == 93); + try expect(v[356] == 94); + try expect(v[357] == 95); + try expect(v[358] == 96); + try expect(v[359] == 97); + try expect(v[360] == 98); + try expect(v[361] == 99); + try expect(v[362] == 0); + try expect(v[363] == 1); + try expect(v[364] == 2); + try expect(v[365] == 3); + try expect(v[366] == 4); + try expect(v[367] == 5); + try expect(v[368] == 6); + try expect(v[369] == 7); + try expect(v[370] == 8); + try expect(v[371] == 9); + try expect(v[372] == 10); + try expect(v[373] == 11); + try expect(v[374] == 12); + try expect(v[375] == 13); + try expect(v[376] == 14); + try expect(v[377] == 15); + try expect(v[378] == 16); + try expect(v[379] == 17); + try expect(v[380] == 18); + try expect(v[381] == 19); + try expect(v[382] == 20); + try expect(v[383] == 21); + try expect(v[384] == 22); + try expect(v[385] == 23); + try expect(v[386] == 24); + try expect(v[387] == 25); + try expect(v[388] == 26); + try expect(v[389] == 27); + try expect(v[390] == 28); + try expect(v[391] == 29); + try expect(v[392] == 30); + try expect(v[393] == 31); + try expect(v[394] == 32); + try expect(v[395] == 33); + try expect(v[396] == 34); + try expect(v[397] == 35); + try expect(v[398] == 36); + try expect(v[399] == 37); + try expect(v[400] == 38); + try expect(v[401] == 39); + try expect(v[402] == 40); + try expect(v[403] == 41); + try expect(v[404] == 42); + try expect(v[405] == 43); + try expect(v[406] == 44); + try expect(v[407] == 45); + try expect(v[408] == 46); + try expect(v[409] == 47); + try expect(v[410] == 48); + try expect(v[411] == 49); + try expect(v[412] == 50); + try expect(v[413] == 51); + try expect(v[414] == 52); + try expect(v[415] == 53); + try expect(v[416] == 54); + try expect(v[417] == 55); + try expect(v[418] == 56); + try expect(v[419] == 57); + try expect(v[420] == 58); + try expect(v[421] == 59); + try expect(v[422] == 60); + try expect(v[423] == 61); + try expect(v[424] == 62); + try expect(v[425] == 63); + try expect(v[426] == 64); + try expect(v[427] == 65); + try expect(v[428] == 66); + try expect(v[429] == 67); + try expect(v[430] == 68); + try expect(v[431] == 69); + try expect(v[432] == 70); + try expect(v[433] == 71); + try expect(v[434] == 72); + try expect(v[435] == 73); + try expect(v[436] == 74); + try expect(v[437] == 75); + try expect(v[438] == 76); + try expect(v[439] == 77); + try expect(v[440] == 78); + try expect(v[441] == 79); + try expect(v[442] == 80); + try expect(v[443] == 81); + try expect(v[444] == 82); + try expect(v[445] == 83); + try expect(v[446] == 84); + try expect(v[447] == 85); + try expect(v[448] == 86); + try expect(v[449] == 87); + try expect(v[450] == 88); + try expect(v[451] == 89); + try expect(v[452] == 90); + try expect(v[453] == 91); + try expect(v[454] == 92); + try expect(v[455] == 93); + try expect(v[456] == 94); + try expect(v[457] == 95); + try expect(v[458] == 96); + try expect(v[459] == 97); + try expect(v[460] == 98); + try expect(v[461] == 99); + try expect(v[462] == 0); + try expect(v[463] == 1); + try expect(v[464] == 2); + try expect(v[465] == 3); + try expect(v[466] == 4); + try expect(v[467] == 5); + try expect(v[468] == 6); + try expect(v[469] == 7); + try expect(v[470] == 8); + try expect(v[471] == 9); + try expect(v[472] == 10); + try expect(v[473] == 11); + try expect(v[474] == 12); + try expect(v[475] == 13); + try expect(v[476] == 14); + try expect(v[477] == 15); + try expect(v[478] == 16); + try expect(v[479] == 17); + try expect(v[480] == 18); + try expect(v[481] == 19); + try expect(v[482] == 20); + try expect(v[483] == 21); + try expect(v[484] == 22); + try expect(v[485] == 23); + try expect(v[486] == 24); + try expect(v[487] == 25); + try expect(v[488] == 26); + try expect(v[489] == 27); + try expect(v[490] == 28); + try expect(v[491] == 29); + try expect(v[492] == 30); + try expect(v[493] == 31); + try expect(v[494] == 32); + try expect(v[495] == 33); + try expect(v[496] == 34); + try expect(v[497] == 35); + try expect(v[498] == 36); + try expect(v[499] == 37); + try expect(v[500] == 38); + try expect(v[501] == 39); + try expect(v[502] == 40); + try expect(v[503] == 41); + try expect(v[504] == 42); + try expect(v[505] == 43); + try expect(v[506] == 44); + try expect(v[507] == 45); + try expect(v[508] == 46); + try expect(v[509] == 47); + try expect(v[510] == 48); + try expect(v[511] == 49); + c_vector_512_u8(.{ + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + }, 512); + c_test_vector_512_u8(); +} + +export fn zig_ret_vector_1_u16() @Vector(1, u16) { + return .{1}; +} +export fn zig_vector_1_u16(v: @Vector(1, u16), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_u16() @Vector(1, u16); +extern fn c_vector_1_u16(@Vector(1, u16), usize) void; +extern fn c_test_vector_1_u16() void; + +test "@Vector(1, u16)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + + const v = c_ret_vector_1_u16(); + try expect(v[0] == 3); + c_vector_1_u16(.{4}, 1); + c_test_vector_1_u16(); +} + +export fn zig_ret_vector_2_u16() @Vector(2, u16) { + return .{ 5, 6 }; +} +export fn zig_vector_2_u16(v: @Vector(2, u16), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_u16() @Vector(2, u16); +extern fn c_vector_2_u16(@Vector(2, u16), usize) void; +extern fn c_test_vector_2_u16() void; + +test "@Vector(2, u16)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest; + + const v = c_ret_vector_2_u16(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_u16(.{ 11, 12 }, 2); + c_test_vector_2_u16(); +} + +export fn zig_ret_vector_3_u16() @Vector(3, u16) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_u16(v: @Vector(3, u16), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_u16() @Vector(3, u16); +extern fn c_vector_3_u16(@Vector(3, u16), usize) void; +extern fn c_test_vector_3_u16() void; + +test "@Vector(3, u16)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest; + + const v = c_ret_vector_3_u16(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_u16(.{ 22, 23, 24 }, 3); + c_test_vector_3_u16(); +} + +export fn zig_ret_vector_4_u16() @Vector(4, u16) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_u16(v: @Vector(4, u16), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} +export fn zig_vector_4_u16_vector_4_u16(v0: @Vector(4, u16), v1: @Vector(4, u16), i: usize) void { + expect(v0[0] == 33) catch @panic("test failure"); + expect(v0[1] == 34) catch @panic("test failure"); + expect(v0[2] == 35) catch @panic("test failure"); + expect(v0[3] == 36) catch @panic("test failure"); + expect(v1[0] == 37) catch @panic("test failure"); + expect(v1[1] == 38) catch @panic("test failure"); + expect(v1[2] == 39) catch @panic("test failure"); + expect(v1[3] == 40) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_4_u16() @Vector(4, u16); +extern fn c_vector_4_u16(@Vector(4, u16), usize) void; +extern fn c_vector_4_u16_vector_4_u16(@Vector(4, u16), @Vector(4, u16), usize) void; +extern fn c_test_vector_4_u16() void; + +test "@Vector(4, u16)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const v = c_ret_vector_4_u16(); + try expect(v[0] == 41); + try expect(v[1] == 42); + try expect(v[2] == 43); + try expect(v[3] == 44); + c_vector_4_u16(.{ 45, 46, 47, 48 }, 4); + c_vector_4_u16_vector_4_u16(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8); + c_test_vector_4_u16(); +} + +export fn zig_ret_vector_6_u16() @Vector(6, u16) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_u16(v: @Vector(6, u16), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_u16() @Vector(6, u16); +extern fn c_vector_6_u16(@Vector(6, u16), usize) void; +extern fn c_test_vector_6_u16() void; + +test "@Vector(6, u16)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + + const v = c_ret_vector_6_u16(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_u16(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_u16(); +} + +export fn zig_ret_vector_8_u16() @Vector(8, u16) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_u16(v: @Vector(8, u16), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_u16() @Vector(8, u16); +extern fn c_vector_8_u16(@Vector(8, u16), usize) void; +extern fn c_test_vector_8_u16() void; + +test "@Vector(8, u16)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_8_u16(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_u16(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_u16(); +} + +export fn zig_ret_vector_12_u16() @Vector(12, u16) { + return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 }; +} +export fn zig_vector_12_u16(v: @Vector(12, u16), i: usize) void { + expect(v[0] == 109) catch @panic("test failure"); + expect(v[1] == 110) catch @panic("test failure"); + expect(v[2] == 111) catch @panic("test failure"); + expect(v[3] == 112) catch @panic("test failure"); + expect(v[4] == 113) catch @panic("test failure"); + expect(v[5] == 114) catch @panic("test failure"); + expect(v[6] == 115) catch @panic("test failure"); + expect(v[7] == 116) catch @panic("test failure"); + expect(v[8] == 117) catch @panic("test failure"); + expect(v[9] == 118) catch @panic("test failure"); + expect(v[10] == 119) catch @panic("test failure"); + expect(v[11] == 120) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_u16() @Vector(12, u16); +extern fn c_vector_12_u16(@Vector(12, u16), usize) void; +extern fn c_test_vector_12_u16() void; + +test "@Vector(12, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_12_u16(); + try expect(v[0] == 121); + try expect(v[1] == 122); + try expect(v[2] == 123); + try expect(v[3] == 124); + try expect(v[4] == 125); + try expect(v[5] == 126); + try expect(v[6] == 127); + try expect(v[7] == 128); + try expect(v[8] == 129); + try expect(v[9] == 130); + try expect(v[10] == 131); + try expect(v[11] == 132); + c_vector_12_u16(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12); + c_test_vector_12_u16(); +} + +export fn zig_ret_vector_16_u16() @Vector(16, u16) { + return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 }; +} +export fn zig_vector_16_u16(v: @Vector(16, u16), i: usize) void { + expect(v[0] == 161) catch @panic("test failure"); + expect(v[1] == 162) catch @panic("test failure"); + expect(v[2] == 163) catch @panic("test failure"); + expect(v[3] == 164) catch @panic("test failure"); + expect(v[4] == 165) catch @panic("test failure"); + expect(v[5] == 166) catch @panic("test failure"); + expect(v[6] == 167) catch @panic("test failure"); + expect(v[7] == 168) catch @panic("test failure"); + expect(v[8] == 169) catch @panic("test failure"); + expect(v[9] == 170) catch @panic("test failure"); + expect(v[10] == 171) catch @panic("test failure"); + expect(v[11] == 172) catch @panic("test failure"); + expect(v[12] == 173) catch @panic("test failure"); + expect(v[13] == 174) catch @panic("test failure"); + expect(v[14] == 175) catch @panic("test failure"); + expect(v[15] == 176) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_u16() @Vector(16, u16); +extern fn c_vector_16_u16(@Vector(16, u16), usize) void; +extern fn c_test_vector_16_u16() void; + +test "@Vector(16, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_16_u16(); + try expect(v[0] == 177); + try expect(v[1] == 178); + try expect(v[2] == 179); + try expect(v[3] == 180); + try expect(v[4] == 181); + try expect(v[5] == 182); + try expect(v[6] == 183); + try expect(v[7] == 184); + try expect(v[8] == 185); + try expect(v[9] == 186); + try expect(v[10] == 187); + try expect(v[11] == 188); + try expect(v[12] == 189); + try expect(v[13] == 190); + try expect(v[14] == 191); + try expect(v[15] == 192); + c_vector_16_u16(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16); + c_test_vector_16_u16(); +} + +export fn zig_ret_vector_24_u16() @Vector(24, u16) { + return .{ + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, + }; +} +export fn zig_vector_24_u16(v: @Vector(24, u16), i: usize) void { + expect(v[0] == 233) catch @panic("test failure"); + expect(v[1] == 234) catch @panic("test failure"); + expect(v[2] == 235) catch @panic("test failure"); + expect(v[3] == 236) catch @panic("test failure"); + expect(v[4] == 237) catch @panic("test failure"); + expect(v[5] == 238) catch @panic("test failure"); + expect(v[6] == 239) catch @panic("test failure"); + expect(v[7] == 240) catch @panic("test failure"); + expect(v[8] == 241) catch @panic("test failure"); + expect(v[9] == 242) catch @panic("test failure"); + expect(v[10] == 243) catch @panic("test failure"); + expect(v[11] == 244) catch @panic("test failure"); + expect(v[12] == 245) catch @panic("test failure"); + expect(v[13] == 246) catch @panic("test failure"); + expect(v[14] == 247) catch @panic("test failure"); + expect(v[15] == 248) catch @panic("test failure"); + expect(v[16] == 249) catch @panic("test failure"); + expect(v[17] == 250) catch @panic("test failure"); + expect(v[18] == 251) catch @panic("test failure"); + expect(v[19] == 252) catch @panic("test failure"); + expect(v[20] == 253) catch @panic("test failure"); + expect(v[21] == 254) catch @panic("test failure"); + expect(v[22] == 255) catch @panic("test failure"); + expect(v[23] == 256) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_u16() @Vector(24, u16); +extern fn c_vector_24_u16(@Vector(24, u16), usize) void; +extern fn c_test_vector_24_u16() void; + +test "@Vector(24, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_24_u16(); + try expect(v[0] == 257); + try expect(v[1] == 258); + try expect(v[2] == 259); + try expect(v[3] == 260); + try expect(v[4] == 261); + try expect(v[5] == 262); + try expect(v[6] == 263); + try expect(v[7] == 264); + try expect(v[8] == 265); + try expect(v[9] == 266); + try expect(v[10] == 267); + try expect(v[11] == 268); + try expect(v[12] == 269); + try expect(v[13] == 270); + try expect(v[14] == 271); + try expect(v[15] == 272); + try expect(v[16] == 273); + try expect(v[17] == 274); + try expect(v[18] == 275); + try expect(v[19] == 276); + try expect(v[20] == 277); + try expect(v[21] == 278); + try expect(v[22] == 279); + try expect(v[23] == 280); + c_vector_24_u16(.{ + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, + }, 24); + c_test_vector_24_u16(); +} + +export fn zig_ret_vector_32_u16() @Vector(32, u16) { + return .{ + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + }; +} +export fn zig_vector_32_u16(v: @Vector(32, u16), i: usize) void { + expect(v[0] == 337) catch @panic("test failure"); + expect(v[1] == 338) catch @panic("test failure"); + expect(v[2] == 339) catch @panic("test failure"); + expect(v[3] == 340) catch @panic("test failure"); + expect(v[4] == 341) catch @panic("test failure"); + expect(v[5] == 342) catch @panic("test failure"); + expect(v[6] == 343) catch @panic("test failure"); + expect(v[7] == 344) catch @panic("test failure"); + expect(v[8] == 345) catch @panic("test failure"); + expect(v[9] == 346) catch @panic("test failure"); + expect(v[10] == 347) catch @panic("test failure"); + expect(v[11] == 348) catch @panic("test failure"); + expect(v[12] == 349) catch @panic("test failure"); + expect(v[13] == 350) catch @panic("test failure"); + expect(v[14] == 351) catch @panic("test failure"); + expect(v[15] == 352) catch @panic("test failure"); + expect(v[16] == 353) catch @panic("test failure"); + expect(v[17] == 354) catch @panic("test failure"); + expect(v[18] == 355) catch @panic("test failure"); + expect(v[19] == 356) catch @panic("test failure"); + expect(v[20] == 357) catch @panic("test failure"); + expect(v[21] == 358) catch @panic("test failure"); + expect(v[22] == 359) catch @panic("test failure"); + expect(v[23] == 360) catch @panic("test failure"); + expect(v[24] == 361) catch @panic("test failure"); + expect(v[25] == 362) catch @panic("test failure"); + expect(v[26] == 363) catch @panic("test failure"); + expect(v[27] == 364) catch @panic("test failure"); + expect(v[28] == 365) catch @panic("test failure"); + expect(v[29] == 366) catch @panic("test failure"); + expect(v[30] == 367) catch @panic("test failure"); + expect(v[31] == 368) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_u16() @Vector(32, u16); +extern fn c_vector_32_u16(@Vector(32, u16), usize) void; +extern fn c_test_vector_32_u16() void; + +test "@Vector(32, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_u16(); + try expect(v[0] == 369); + try expect(v[1] == 370); + try expect(v[2] == 371); + try expect(v[3] == 372); + try expect(v[4] == 373); + try expect(v[5] == 374); + try expect(v[6] == 375); + try expect(v[7] == 376); + try expect(v[8] == 377); + try expect(v[9] == 378); + try expect(v[10] == 379); + try expect(v[11] == 380); + try expect(v[12] == 381); + try expect(v[13] == 382); + try expect(v[14] == 383); + try expect(v[15] == 384); + try expect(v[16] == 385); + try expect(v[17] == 386); + try expect(v[18] == 387); + try expect(v[19] == 388); + try expect(v[20] == 389); + try expect(v[21] == 390); + try expect(v[22] == 391); + try expect(v[23] == 392); + try expect(v[24] == 393); + try expect(v[25] == 394); + try expect(v[26] == 395); + try expect(v[27] == 396); + try expect(v[28] == 397); + try expect(v[29] == 398); + try expect(v[30] == 399); + try expect(v[31] == 400); + c_vector_32_u16(.{ + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + }, 32); + c_test_vector_32_u16(); +} + +export fn zig_ret_vector_48_u16() @Vector(48, u16) { + return .{ + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + }; +} +export fn zig_vector_48_u16(v: @Vector(48, u16), i: usize) void { + expect(v[0] == 481) catch @panic("test failure"); + expect(v[1] == 482) catch @panic("test failure"); + expect(v[2] == 483) catch @panic("test failure"); + expect(v[3] == 484) catch @panic("test failure"); + expect(v[4] == 485) catch @panic("test failure"); + expect(v[5] == 486) catch @panic("test failure"); + expect(v[6] == 487) catch @panic("test failure"); + expect(v[7] == 488) catch @panic("test failure"); + expect(v[8] == 489) catch @panic("test failure"); + expect(v[9] == 490) catch @panic("test failure"); + expect(v[10] == 491) catch @panic("test failure"); + expect(v[11] == 492) catch @panic("test failure"); + expect(v[12] == 493) catch @panic("test failure"); + expect(v[13] == 494) catch @panic("test failure"); + expect(v[14] == 495) catch @panic("test failure"); + expect(v[15] == 496) catch @panic("test failure"); + expect(v[16] == 497) catch @panic("test failure"); + expect(v[17] == 498) catch @panic("test failure"); + expect(v[18] == 499) catch @panic("test failure"); + expect(v[19] == 500) catch @panic("test failure"); + expect(v[20] == 501) catch @panic("test failure"); + expect(v[21] == 502) catch @panic("test failure"); + expect(v[22] == 503) catch @panic("test failure"); + expect(v[23] == 504) catch @panic("test failure"); + expect(v[24] == 505) catch @panic("test failure"); + expect(v[25] == 506) catch @panic("test failure"); + expect(v[26] == 507) catch @panic("test failure"); + expect(v[27] == 508) catch @panic("test failure"); + expect(v[28] == 509) catch @panic("test failure"); + expect(v[29] == 510) catch @panic("test failure"); + expect(v[30] == 511) catch @panic("test failure"); + expect(v[31] == 512) catch @panic("test failure"); + expect(v[32] == 513) catch @panic("test failure"); + expect(v[33] == 514) catch @panic("test failure"); + expect(v[34] == 515) catch @panic("test failure"); + expect(v[35] == 516) catch @panic("test failure"); + expect(v[36] == 517) catch @panic("test failure"); + expect(v[37] == 518) catch @panic("test failure"); + expect(v[38] == 519) catch @panic("test failure"); + expect(v[39] == 520) catch @panic("test failure"); + expect(v[40] == 521) catch @panic("test failure"); + expect(v[41] == 522) catch @panic("test failure"); + expect(v[42] == 523) catch @panic("test failure"); + expect(v[43] == 524) catch @panic("test failure"); + expect(v[44] == 525) catch @panic("test failure"); + expect(v[45] == 526) catch @panic("test failure"); + expect(v[46] == 527) catch @panic("test failure"); + expect(v[47] == 528) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_u16() @Vector(48, u16); +extern fn c_vector_48_u16(@Vector(48, u16), usize) void; +extern fn c_test_vector_48_u16() void; + +test "@Vector(48, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_48_u16(); + try expect(v[0] == 529); + try expect(v[1] == 530); + try expect(v[2] == 531); + try expect(v[3] == 532); + try expect(v[4] == 533); + try expect(v[5] == 534); + try expect(v[6] == 535); + try expect(v[7] == 536); + try expect(v[8] == 537); + try expect(v[9] == 538); + try expect(v[10] == 539); + try expect(v[11] == 540); + try expect(v[12] == 541); + try expect(v[13] == 542); + try expect(v[14] == 543); + try expect(v[15] == 544); + try expect(v[16] == 545); + try expect(v[17] == 546); + try expect(v[18] == 547); + try expect(v[19] == 548); + try expect(v[20] == 549); + try expect(v[21] == 550); + try expect(v[22] == 551); + try expect(v[23] == 552); + try expect(v[24] == 553); + try expect(v[25] == 554); + try expect(v[26] == 555); + try expect(v[27] == 556); + try expect(v[28] == 557); + try expect(v[29] == 558); + try expect(v[30] == 559); + try expect(v[31] == 560); + try expect(v[32] == 561); + try expect(v[33] == 562); + try expect(v[34] == 563); + try expect(v[35] == 564); + try expect(v[36] == 565); + try expect(v[37] == 566); + try expect(v[38] == 567); + try expect(v[39] == 568); + try expect(v[40] == 569); + try expect(v[41] == 570); + try expect(v[42] == 571); + try expect(v[43] == 572); + try expect(v[44] == 573); + try expect(v[45] == 574); + try expect(v[46] == 575); + try expect(v[47] == 576); + c_vector_48_u16(.{ + 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, + 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, + 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + }, 48); + c_test_vector_48_u16(); +} + +export fn zig_ret_vector_64_u16() @Vector(64, u16) { + return .{ + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, + 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, + 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, + }; +} +export fn zig_vector_64_u16(v: @Vector(64, u16), i: usize) void { + expect(v[0] == 689) catch @panic("test failure"); + expect(v[1] == 690) catch @panic("test failure"); + expect(v[2] == 691) catch @panic("test failure"); + expect(v[3] == 692) catch @panic("test failure"); + expect(v[4] == 693) catch @panic("test failure"); + expect(v[5] == 694) catch @panic("test failure"); + expect(v[6] == 695) catch @panic("test failure"); + expect(v[7] == 696) catch @panic("test failure"); + expect(v[8] == 697) catch @panic("test failure"); + expect(v[9] == 698) catch @panic("test failure"); + expect(v[10] == 699) catch @panic("test failure"); + expect(v[11] == 700) catch @panic("test failure"); + expect(v[12] == 701) catch @panic("test failure"); + expect(v[13] == 702) catch @panic("test failure"); + expect(v[14] == 703) catch @panic("test failure"); + expect(v[15] == 704) catch @panic("test failure"); + expect(v[16] == 705) catch @panic("test failure"); + expect(v[17] == 706) catch @panic("test failure"); + expect(v[18] == 707) catch @panic("test failure"); + expect(v[19] == 708) catch @panic("test failure"); + expect(v[20] == 709) catch @panic("test failure"); + expect(v[21] == 710) catch @panic("test failure"); + expect(v[22] == 711) catch @panic("test failure"); + expect(v[23] == 712) catch @panic("test failure"); + expect(v[24] == 713) catch @panic("test failure"); + expect(v[25] == 714) catch @panic("test failure"); + expect(v[26] == 715) catch @panic("test failure"); + expect(v[27] == 716) catch @panic("test failure"); + expect(v[28] == 717) catch @panic("test failure"); + expect(v[29] == 718) catch @panic("test failure"); + expect(v[30] == 719) catch @panic("test failure"); + expect(v[31] == 720) catch @panic("test failure"); + expect(v[32] == 721) catch @panic("test failure"); + expect(v[33] == 722) catch @panic("test failure"); + expect(v[34] == 723) catch @panic("test failure"); + expect(v[35] == 724) catch @panic("test failure"); + expect(v[36] == 725) catch @panic("test failure"); + expect(v[37] == 726) catch @panic("test failure"); + expect(v[38] == 727) catch @panic("test failure"); + expect(v[39] == 728) catch @panic("test failure"); + expect(v[40] == 729) catch @panic("test failure"); + expect(v[41] == 730) catch @panic("test failure"); + expect(v[42] == 731) catch @panic("test failure"); + expect(v[43] == 732) catch @panic("test failure"); + expect(v[44] == 733) catch @panic("test failure"); + expect(v[45] == 734) catch @panic("test failure"); + expect(v[46] == 735) catch @panic("test failure"); + expect(v[47] == 736) catch @panic("test failure"); + expect(v[48] == 737) catch @panic("test failure"); + expect(v[49] == 738) catch @panic("test failure"); + expect(v[50] == 739) catch @panic("test failure"); + expect(v[51] == 740) catch @panic("test failure"); + expect(v[52] == 741) catch @panic("test failure"); + expect(v[53] == 742) catch @panic("test failure"); + expect(v[54] == 743) catch @panic("test failure"); + expect(v[55] == 744) catch @panic("test failure"); + expect(v[56] == 745) catch @panic("test failure"); + expect(v[57] == 746) catch @panic("test failure"); + expect(v[58] == 747) catch @panic("test failure"); + expect(v[59] == 748) catch @panic("test failure"); + expect(v[60] == 749) catch @panic("test failure"); + expect(v[61] == 750) catch @panic("test failure"); + expect(v[62] == 751) catch @panic("test failure"); + expect(v[63] == 752) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_u16() @Vector(64, u16); +extern fn c_vector_64_u16(@Vector(64, u16), usize) void; +extern fn c_test_vector_64_u16() void; + +test "@Vector(64, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_u16(); + try expect(v[0] == 753); + try expect(v[1] == 754); + try expect(v[2] == 755); + try expect(v[3] == 756); + try expect(v[4] == 757); + try expect(v[5] == 758); + try expect(v[6] == 759); + try expect(v[7] == 760); + try expect(v[8] == 761); + try expect(v[9] == 762); + try expect(v[10] == 763); + try expect(v[11] == 764); + try expect(v[12] == 765); + try expect(v[13] == 766); + try expect(v[14] == 767); + try expect(v[15] == 768); + try expect(v[16] == 769); + try expect(v[17] == 770); + try expect(v[18] == 771); + try expect(v[19] == 772); + try expect(v[20] == 773); + try expect(v[21] == 774); + try expect(v[22] == 775); + try expect(v[23] == 776); + try expect(v[24] == 777); + try expect(v[25] == 778); + try expect(v[26] == 779); + try expect(v[27] == 780); + try expect(v[28] == 781); + try expect(v[29] == 782); + try expect(v[30] == 783); + try expect(v[31] == 784); + try expect(v[32] == 785); + try expect(v[33] == 786); + try expect(v[34] == 787); + try expect(v[35] == 788); + try expect(v[36] == 789); + try expect(v[37] == 790); + try expect(v[38] == 791); + try expect(v[39] == 792); + try expect(v[40] == 793); + try expect(v[41] == 794); + try expect(v[42] == 795); + try expect(v[43] == 796); + try expect(v[44] == 797); + try expect(v[45] == 798); + try expect(v[46] == 799); + try expect(v[47] == 800); + try expect(v[48] == 801); + try expect(v[49] == 802); + try expect(v[50] == 803); + try expect(v[51] == 804); + try expect(v[52] == 805); + try expect(v[53] == 806); + try expect(v[54] == 807); + try expect(v[55] == 808); + try expect(v[56] == 809); + try expect(v[57] == 810); + try expect(v[58] == 811); + try expect(v[59] == 812); + try expect(v[60] == 813); + try expect(v[61] == 814); + try expect(v[62] == 815); + try expect(v[63] == 816); + c_vector_64_u16(.{ + 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, + }, 64); + c_test_vector_64_u16(); +} + +export fn zig_ret_vector_96_u16() @Vector(96, u16) { + return .{ + 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, + 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, + 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, + 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, + 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, + }; +} +export fn zig_vector_96_u16(v: @Vector(96, u16), i: usize) void { + expect(v[0] == 986) catch @panic("test failure"); + expect(v[1] == 987) catch @panic("test failure"); + expect(v[2] == 988) catch @panic("test failure"); + expect(v[3] == 989) catch @panic("test failure"); + expect(v[4] == 990) catch @panic("test failure"); + expect(v[5] == 991) catch @panic("test failure"); + expect(v[6] == 992) catch @panic("test failure"); + expect(v[7] == 993) catch @panic("test failure"); + expect(v[8] == 994) catch @panic("test failure"); + expect(v[9] == 995) catch @panic("test failure"); + expect(v[10] == 996) catch @panic("test failure"); + expect(v[11] == 997) catch @panic("test failure"); + expect(v[12] == 998) catch @panic("test failure"); + expect(v[13] == 999) catch @panic("test failure"); + expect(v[14] == 1000) catch @panic("test failure"); + expect(v[15] == 1001) catch @panic("test failure"); + expect(v[16] == 1002) catch @panic("test failure"); + expect(v[17] == 1003) catch @panic("test failure"); + expect(v[18] == 1004) catch @panic("test failure"); + expect(v[19] == 1005) catch @panic("test failure"); + expect(v[20] == 1006) catch @panic("test failure"); + expect(v[21] == 1007) catch @panic("test failure"); + expect(v[22] == 1008) catch @panic("test failure"); + expect(v[23] == 1009) catch @panic("test failure"); + expect(v[24] == 1010) catch @panic("test failure"); + expect(v[25] == 1011) catch @panic("test failure"); + expect(v[26] == 1012) catch @panic("test failure"); + expect(v[27] == 1013) catch @panic("test failure"); + expect(v[28] == 1014) catch @panic("test failure"); + expect(v[29] == 1015) catch @panic("test failure"); + expect(v[30] == 1016) catch @panic("test failure"); + expect(v[31] == 1017) catch @panic("test failure"); + expect(v[32] == 1018) catch @panic("test failure"); + expect(v[33] == 1019) catch @panic("test failure"); + expect(v[34] == 1020) catch @panic("test failure"); + expect(v[35] == 1021) catch @panic("test failure"); + expect(v[36] == 1022) catch @panic("test failure"); + expect(v[37] == 1023) catch @panic("test failure"); + expect(v[38] == 1024) catch @panic("test failure"); + expect(v[39] == 1025) catch @panic("test failure"); + expect(v[40] == 1026) catch @panic("test failure"); + expect(v[41] == 1027) catch @panic("test failure"); + expect(v[42] == 1028) catch @panic("test failure"); + expect(v[43] == 1029) catch @panic("test failure"); + expect(v[44] == 1030) catch @panic("test failure"); + expect(v[45] == 1031) catch @panic("test failure"); + expect(v[46] == 1032) catch @panic("test failure"); + expect(v[47] == 1033) catch @panic("test failure"); + expect(v[48] == 1034) catch @panic("test failure"); + expect(v[49] == 1035) catch @panic("test failure"); + expect(v[50] == 1036) catch @panic("test failure"); + expect(v[51] == 1037) catch @panic("test failure"); + expect(v[52] == 1038) catch @panic("test failure"); + expect(v[53] == 1039) catch @panic("test failure"); + expect(v[54] == 1040) catch @panic("test failure"); + expect(v[55] == 1041) catch @panic("test failure"); + expect(v[56] == 1042) catch @panic("test failure"); + expect(v[57] == 1043) catch @panic("test failure"); + expect(v[58] == 1044) catch @panic("test failure"); + expect(v[59] == 1045) catch @panic("test failure"); + expect(v[60] == 1046) catch @panic("test failure"); + expect(v[61] == 1047) catch @panic("test failure"); + expect(v[62] == 1048) catch @panic("test failure"); + expect(v[63] == 1049) catch @panic("test failure"); + expect(v[64] == 1050) catch @panic("test failure"); + expect(v[65] == 1051) catch @panic("test failure"); + expect(v[66] == 1052) catch @panic("test failure"); + expect(v[67] == 1053) catch @panic("test failure"); + expect(v[68] == 1054) catch @panic("test failure"); + expect(v[69] == 1055) catch @panic("test failure"); + expect(v[70] == 1056) catch @panic("test failure"); + expect(v[71] == 1057) catch @panic("test failure"); + expect(v[72] == 1058) catch @panic("test failure"); + expect(v[73] == 1059) catch @panic("test failure"); + expect(v[74] == 1060) catch @panic("test failure"); + expect(v[75] == 1061) catch @panic("test failure"); + expect(v[76] == 1062) catch @panic("test failure"); + expect(v[77] == 1063) catch @panic("test failure"); + expect(v[78] == 1064) catch @panic("test failure"); + expect(v[79] == 1065) catch @panic("test failure"); + expect(v[80] == 1066) catch @panic("test failure"); + expect(v[81] == 1067) catch @panic("test failure"); + expect(v[82] == 1068) catch @panic("test failure"); + expect(v[83] == 1069) catch @panic("test failure"); + expect(v[84] == 1070) catch @panic("test failure"); + expect(v[85] == 1071) catch @panic("test failure"); + expect(v[86] == 1072) catch @panic("test failure"); + expect(v[87] == 1073) catch @panic("test failure"); + expect(v[88] == 1074) catch @panic("test failure"); + expect(v[89] == 1075) catch @panic("test failure"); + expect(v[90] == 1076) catch @panic("test failure"); + expect(v[91] == 1077) catch @panic("test failure"); + expect(v[92] == 1078) catch @panic("test failure"); + expect(v[93] == 1079) catch @panic("test failure"); + expect(v[94] == 1080) catch @panic("test failure"); + expect(v[95] == 1081) catch @panic("test failure"); + expect(i == 96) catch @panic("test failure"); +} + +extern fn c_ret_vector_96_u16() @Vector(96, u16); +extern fn c_vector_96_u16(@Vector(96, u16), usize) void; +extern fn c_test_vector_96_u16() void; + +test "@Vector(96, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_96_u16(); + try expect(v[0] == 1082); + try expect(v[1] == 1083); + try expect(v[2] == 1084); + try expect(v[3] == 1085); + try expect(v[4] == 1086); + try expect(v[5] == 1087); + try expect(v[6] == 1088); + try expect(v[7] == 1089); + try expect(v[8] == 1090); + try expect(v[9] == 1091); + try expect(v[10] == 1092); + try expect(v[11] == 1093); + try expect(v[12] == 1094); + try expect(v[13] == 1095); + try expect(v[14] == 1096); + try expect(v[15] == 1097); + try expect(v[16] == 1098); + try expect(v[17] == 1099); + try expect(v[18] == 1100); + try expect(v[19] == 1101); + try expect(v[20] == 1102); + try expect(v[21] == 1103); + try expect(v[22] == 1104); + try expect(v[23] == 1105); + try expect(v[24] == 1106); + try expect(v[25] == 1107); + try expect(v[26] == 1108); + try expect(v[27] == 1109); + try expect(v[28] == 1110); + try expect(v[29] == 1111); + try expect(v[30] == 1112); + try expect(v[31] == 1113); + try expect(v[32] == 1114); + try expect(v[33] == 1115); + try expect(v[34] == 1116); + try expect(v[35] == 1117); + try expect(v[36] == 1118); + try expect(v[37] == 1119); + try expect(v[38] == 1120); + try expect(v[39] == 1121); + try expect(v[40] == 1122); + try expect(v[41] == 1123); + try expect(v[42] == 1124); + try expect(v[43] == 1125); + try expect(v[44] == 1126); + try expect(v[45] == 1127); + try expect(v[46] == 1128); + try expect(v[47] == 1129); + try expect(v[48] == 1130); + try expect(v[49] == 1131); + try expect(v[50] == 1132); + try expect(v[51] == 1133); + try expect(v[52] == 1134); + try expect(v[53] == 1135); + try expect(v[54] == 1136); + try expect(v[55] == 1137); + try expect(v[56] == 1138); + try expect(v[57] == 1139); + try expect(v[58] == 1140); + try expect(v[59] == 1141); + try expect(v[60] == 1142); + try expect(v[61] == 1143); + try expect(v[62] == 1144); + try expect(v[63] == 1145); + try expect(v[64] == 1146); + try expect(v[65] == 1147); + try expect(v[66] == 1148); + try expect(v[67] == 1149); + try expect(v[68] == 1150); + try expect(v[69] == 1151); + try expect(v[70] == 1152); + try expect(v[71] == 1153); + try expect(v[72] == 1154); + try expect(v[73] == 1155); + try expect(v[74] == 1156); + try expect(v[75] == 1157); + try expect(v[76] == 1158); + try expect(v[77] == 1159); + try expect(v[78] == 1160); + try expect(v[79] == 1161); + try expect(v[80] == 1162); + try expect(v[81] == 1163); + try expect(v[82] == 1164); + try expect(v[83] == 1165); + try expect(v[84] == 1166); + try expect(v[85] == 1167); + try expect(v[86] == 1168); + try expect(v[87] == 1169); + try expect(v[88] == 1170); + try expect(v[89] == 1171); + try expect(v[90] == 1172); + try expect(v[91] == 1173); + try expect(v[92] == 1174); + try expect(v[93] == 1175); + try expect(v[94] == 1176); + try expect(v[95] == 1177); + c_vector_96_u16(.{ + 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, + 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, + 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, + 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, + 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, + 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, + }, 96); + c_test_vector_96_u16(); +} + +export fn zig_ret_vector_128_u16() @Vector(128, u16) { + return .{ + 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, + 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, + 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, + 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, + 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, + 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, + 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, + }; +} +export fn zig_vector_128_u16(v: @Vector(128, u16), i: usize) void { + expect(v[0] == 1402) catch @panic("test failure"); + expect(v[1] == 1403) catch @panic("test failure"); + expect(v[2] == 1404) catch @panic("test failure"); + expect(v[3] == 1405) catch @panic("test failure"); + expect(v[4] == 1406) catch @panic("test failure"); + expect(v[5] == 1407) catch @panic("test failure"); + expect(v[6] == 1408) catch @panic("test failure"); + expect(v[7] == 1409) catch @panic("test failure"); + expect(v[8] == 1410) catch @panic("test failure"); + expect(v[9] == 1411) catch @panic("test failure"); + expect(v[10] == 1412) catch @panic("test failure"); + expect(v[11] == 1413) catch @panic("test failure"); + expect(v[12] == 1414) catch @panic("test failure"); + expect(v[13] == 1415) catch @panic("test failure"); + expect(v[14] == 1416) catch @panic("test failure"); + expect(v[15] == 1417) catch @panic("test failure"); + expect(v[16] == 1418) catch @panic("test failure"); + expect(v[17] == 1419) catch @panic("test failure"); + expect(v[18] == 1420) catch @panic("test failure"); + expect(v[19] == 1421) catch @panic("test failure"); + expect(v[20] == 1422) catch @panic("test failure"); + expect(v[21] == 1423) catch @panic("test failure"); + expect(v[22] == 1424) catch @panic("test failure"); + expect(v[23] == 1425) catch @panic("test failure"); + expect(v[24] == 1426) catch @panic("test failure"); + expect(v[25] == 1427) catch @panic("test failure"); + expect(v[26] == 1428) catch @panic("test failure"); + expect(v[27] == 1429) catch @panic("test failure"); + expect(v[28] == 1430) catch @panic("test failure"); + expect(v[29] == 1431) catch @panic("test failure"); + expect(v[30] == 1432) catch @panic("test failure"); + expect(v[31] == 1433) catch @panic("test failure"); + expect(v[32] == 1434) catch @panic("test failure"); + expect(v[33] == 1435) catch @panic("test failure"); + expect(v[34] == 1436) catch @panic("test failure"); + expect(v[35] == 1437) catch @panic("test failure"); + expect(v[36] == 1438) catch @panic("test failure"); + expect(v[37] == 1439) catch @panic("test failure"); + expect(v[38] == 1440) catch @panic("test failure"); + expect(v[39] == 1441) catch @panic("test failure"); + expect(v[40] == 1442) catch @panic("test failure"); + expect(v[41] == 1443) catch @panic("test failure"); + expect(v[42] == 1444) catch @panic("test failure"); + expect(v[43] == 1445) catch @panic("test failure"); + expect(v[44] == 1446) catch @panic("test failure"); + expect(v[45] == 1447) catch @panic("test failure"); + expect(v[46] == 1448) catch @panic("test failure"); + expect(v[47] == 1449) catch @panic("test failure"); + expect(v[48] == 1450) catch @panic("test failure"); + expect(v[49] == 1451) catch @panic("test failure"); + expect(v[50] == 1452) catch @panic("test failure"); + expect(v[51] == 1453) catch @panic("test failure"); + expect(v[52] == 1454) catch @panic("test failure"); + expect(v[53] == 1455) catch @panic("test failure"); + expect(v[54] == 1456) catch @panic("test failure"); + expect(v[55] == 1457) catch @panic("test failure"); + expect(v[56] == 1458) catch @panic("test failure"); + expect(v[57] == 1459) catch @panic("test failure"); + expect(v[58] == 1460) catch @panic("test failure"); + expect(v[59] == 1461) catch @panic("test failure"); + expect(v[60] == 1462) catch @panic("test failure"); + expect(v[61] == 1463) catch @panic("test failure"); + expect(v[62] == 1464) catch @panic("test failure"); + expect(v[63] == 1465) catch @panic("test failure"); + expect(v[64] == 1466) catch @panic("test failure"); + expect(v[65] == 1467) catch @panic("test failure"); + expect(v[66] == 1468) catch @panic("test failure"); + expect(v[67] == 1469) catch @panic("test failure"); + expect(v[68] == 1470) catch @panic("test failure"); + expect(v[69] == 1471) catch @panic("test failure"); + expect(v[70] == 1472) catch @panic("test failure"); + expect(v[71] == 1473) catch @panic("test failure"); + expect(v[72] == 1474) catch @panic("test failure"); + expect(v[73] == 1475) catch @panic("test failure"); + expect(v[74] == 1476) catch @panic("test failure"); + expect(v[75] == 1477) catch @panic("test failure"); + expect(v[76] == 1478) catch @panic("test failure"); + expect(v[77] == 1479) catch @panic("test failure"); + expect(v[78] == 1480) catch @panic("test failure"); + expect(v[79] == 1481) catch @panic("test failure"); + expect(v[80] == 1482) catch @panic("test failure"); + expect(v[81] == 1483) catch @panic("test failure"); + expect(v[82] == 1484) catch @panic("test failure"); + expect(v[83] == 1485) catch @panic("test failure"); + expect(v[84] == 1486) catch @panic("test failure"); + expect(v[85] == 1487) catch @panic("test failure"); + expect(v[86] == 1488) catch @panic("test failure"); + expect(v[87] == 1489) catch @panic("test failure"); + expect(v[88] == 1490) catch @panic("test failure"); + expect(v[89] == 1491) catch @panic("test failure"); + expect(v[90] == 1492) catch @panic("test failure"); + expect(v[91] == 1493) catch @panic("test failure"); + expect(v[92] == 1494) catch @panic("test failure"); + expect(v[93] == 1495) catch @panic("test failure"); + expect(v[94] == 1496) catch @panic("test failure"); + expect(v[95] == 1497) catch @panic("test failure"); + expect(v[96] == 1498) catch @panic("test failure"); + expect(v[97] == 1499) catch @panic("test failure"); + expect(v[98] == 1500) catch @panic("test failure"); + expect(v[99] == 1501) catch @panic("test failure"); + expect(v[100] == 1502) catch @panic("test failure"); + expect(v[101] == 1503) catch @panic("test failure"); + expect(v[102] == 1504) catch @panic("test failure"); + expect(v[103] == 1505) catch @panic("test failure"); + expect(v[104] == 1506) catch @panic("test failure"); + expect(v[105] == 1507) catch @panic("test failure"); + expect(v[106] == 1508) catch @panic("test failure"); + expect(v[107] == 1509) catch @panic("test failure"); + expect(v[108] == 1510) catch @panic("test failure"); + expect(v[109] == 1511) catch @panic("test failure"); + expect(v[110] == 1512) catch @panic("test failure"); + expect(v[111] == 1513) catch @panic("test failure"); + expect(v[112] == 1514) catch @panic("test failure"); + expect(v[113] == 1515) catch @panic("test failure"); + expect(v[114] == 1516) catch @panic("test failure"); + expect(v[115] == 1517) catch @panic("test failure"); + expect(v[116] == 1518) catch @panic("test failure"); + expect(v[117] == 1519) catch @panic("test failure"); + expect(v[118] == 1520) catch @panic("test failure"); + expect(v[119] == 1521) catch @panic("test failure"); + expect(v[120] == 1522) catch @panic("test failure"); + expect(v[121] == 1523) catch @panic("test failure"); + expect(v[122] == 1524) catch @panic("test failure"); + expect(v[123] == 1525) catch @panic("test failure"); + expect(v[124] == 1526) catch @panic("test failure"); + expect(v[125] == 1527) catch @panic("test failure"); + expect(v[126] == 1528) catch @panic("test failure"); + expect(v[127] == 1529) catch @panic("test failure"); + expect(i == 128) catch @panic("test failure"); +} + +extern fn c_ret_vector_128_u16() @Vector(128, u16); +extern fn c_vector_128_u16(@Vector(128, u16), usize) void; +extern fn c_test_vector_128_u16() void; + +test "@Vector(128, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_128_u16(); + try expect(v[0] == 1530); + try expect(v[1] == 1531); + try expect(v[2] == 1532); + try expect(v[3] == 1533); + try expect(v[4] == 1534); + try expect(v[5] == 1535); + try expect(v[6] == 1536); + try expect(v[7] == 1537); + try expect(v[8] == 1538); + try expect(v[9] == 1539); + try expect(v[10] == 1540); + try expect(v[11] == 1541); + try expect(v[12] == 1542); + try expect(v[13] == 1543); + try expect(v[14] == 1544); + try expect(v[15] == 1545); + try expect(v[16] == 1546); + try expect(v[17] == 1547); + try expect(v[18] == 1548); + try expect(v[19] == 1549); + try expect(v[20] == 1550); + try expect(v[21] == 1551); + try expect(v[22] == 1552); + try expect(v[23] == 1553); + try expect(v[24] == 1554); + try expect(v[25] == 1555); + try expect(v[26] == 1556); + try expect(v[27] == 1557); + try expect(v[28] == 1558); + try expect(v[29] == 1559); + try expect(v[30] == 1560); + try expect(v[31] == 1561); + try expect(v[32] == 1562); + try expect(v[33] == 1563); + try expect(v[34] == 1564); + try expect(v[35] == 1565); + try expect(v[36] == 1566); + try expect(v[37] == 1567); + try expect(v[38] == 1568); + try expect(v[39] == 1569); + try expect(v[40] == 1570); + try expect(v[41] == 1571); + try expect(v[42] == 1572); + try expect(v[43] == 1573); + try expect(v[44] == 1574); + try expect(v[45] == 1575); + try expect(v[46] == 1576); + try expect(v[47] == 1577); + try expect(v[48] == 1578); + try expect(v[49] == 1579); + try expect(v[50] == 1580); + try expect(v[51] == 1581); + try expect(v[52] == 1582); + try expect(v[53] == 1583); + try expect(v[54] == 1584); + try expect(v[55] == 1585); + try expect(v[56] == 1586); + try expect(v[57] == 1587); + try expect(v[58] == 1588); + try expect(v[59] == 1589); + try expect(v[60] == 1590); + try expect(v[61] == 1591); + try expect(v[62] == 1592); + try expect(v[63] == 1593); + try expect(v[64] == 1594); + try expect(v[65] == 1595); + try expect(v[66] == 1596); + try expect(v[67] == 1597); + try expect(v[68] == 1598); + try expect(v[69] == 1599); + try expect(v[70] == 1600); + try expect(v[71] == 1601); + try expect(v[72] == 1602); + try expect(v[73] == 1603); + try expect(v[74] == 1604); + try expect(v[75] == 1605); + try expect(v[76] == 1606); + try expect(v[77] == 1607); + try expect(v[78] == 1608); + try expect(v[79] == 1609); + try expect(v[80] == 1610); + try expect(v[81] == 1611); + try expect(v[82] == 1612); + try expect(v[83] == 1613); + try expect(v[84] == 1614); + try expect(v[85] == 1615); + try expect(v[86] == 1616); + try expect(v[87] == 1617); + try expect(v[88] == 1618); + try expect(v[89] == 1619); + try expect(v[90] == 1620); + try expect(v[91] == 1621); + try expect(v[92] == 1622); + try expect(v[93] == 1623); + try expect(v[94] == 1624); + try expect(v[95] == 1625); + try expect(v[96] == 1626); + try expect(v[97] == 1627); + try expect(v[98] == 1628); + try expect(v[99] == 1629); + try expect(v[100] == 1630); + try expect(v[101] == 1631); + try expect(v[102] == 1632); + try expect(v[103] == 1633); + try expect(v[104] == 1634); + try expect(v[105] == 1635); + try expect(v[106] == 1636); + try expect(v[107] == 1637); + try expect(v[108] == 1638); + try expect(v[109] == 1639); + try expect(v[110] == 1640); + try expect(v[111] == 1641); + try expect(v[112] == 1642); + try expect(v[113] == 1643); + try expect(v[114] == 1644); + try expect(v[115] == 1645); + try expect(v[116] == 1646); + try expect(v[117] == 1647); + try expect(v[118] == 1648); + try expect(v[119] == 1649); + try expect(v[120] == 1650); + try expect(v[121] == 1651); + try expect(v[122] == 1652); + try expect(v[123] == 1653); + try expect(v[124] == 1654); + try expect(v[125] == 1655); + try expect(v[126] == 1656); + try expect(v[127] == 1657); + c_vector_128_u16(.{ + 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, + 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, + 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, + 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, + 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, + 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, + 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, + 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, + }, 128); + c_test_vector_128_u16(); +} + +export fn zig_ret_vector_192_u16() @Vector(192, u16) { + return .{ + 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, + 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, + 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, + 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, + 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, + 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881, + 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, + 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, + 1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, + 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, + 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961, + 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, + }; +} +export fn zig_vector_192_u16(v: @Vector(192, u16), i: usize) void { + expect(v[0] == 1978) catch @panic("test failure"); + expect(v[1] == 1979) catch @panic("test failure"); + expect(v[2] == 1980) catch @panic("test failure"); + expect(v[3] == 1981) catch @panic("test failure"); + expect(v[4] == 1982) catch @panic("test failure"); + expect(v[5] == 1983) catch @panic("test failure"); + expect(v[6] == 1984) catch @panic("test failure"); + expect(v[7] == 1985) catch @panic("test failure"); + expect(v[8] == 1986) catch @panic("test failure"); + expect(v[9] == 1987) catch @panic("test failure"); + expect(v[10] == 1988) catch @panic("test failure"); + expect(v[11] == 1989) catch @panic("test failure"); + expect(v[12] == 1990) catch @panic("test failure"); + expect(v[13] == 1991) catch @panic("test failure"); + expect(v[14] == 1992) catch @panic("test failure"); + expect(v[15] == 1993) catch @panic("test failure"); + expect(v[16] == 1994) catch @panic("test failure"); + expect(v[17] == 1995) catch @panic("test failure"); + expect(v[18] == 1996) catch @panic("test failure"); + expect(v[19] == 1997) catch @panic("test failure"); + expect(v[20] == 1998) catch @panic("test failure"); + expect(v[21] == 1999) catch @panic("test failure"); + expect(v[22] == 2000) catch @panic("test failure"); + expect(v[23] == 2001) catch @panic("test failure"); + expect(v[24] == 2002) catch @panic("test failure"); + expect(v[25] == 2003) catch @panic("test failure"); + expect(v[26] == 2004) catch @panic("test failure"); + expect(v[27] == 2005) catch @panic("test failure"); + expect(v[28] == 2006) catch @panic("test failure"); + expect(v[29] == 2007) catch @panic("test failure"); + expect(v[30] == 2008) catch @panic("test failure"); + expect(v[31] == 2009) catch @panic("test failure"); + expect(v[32] == 2010) catch @panic("test failure"); + expect(v[33] == 2011) catch @panic("test failure"); + expect(v[34] == 2012) catch @panic("test failure"); + expect(v[35] == 2013) catch @panic("test failure"); + expect(v[36] == 2014) catch @panic("test failure"); + expect(v[37] == 2015) catch @panic("test failure"); + expect(v[38] == 2016) catch @panic("test failure"); + expect(v[39] == 2017) catch @panic("test failure"); + expect(v[40] == 2018) catch @panic("test failure"); + expect(v[41] == 2019) catch @panic("test failure"); + expect(v[42] == 2020) catch @panic("test failure"); + expect(v[43] == 2021) catch @panic("test failure"); + expect(v[44] == 2022) catch @panic("test failure"); + expect(v[45] == 2023) catch @panic("test failure"); + expect(v[46] == 2024) catch @panic("test failure"); + expect(v[47] == 2025) catch @panic("test failure"); + expect(v[48] == 2026) catch @panic("test failure"); + expect(v[49] == 2027) catch @panic("test failure"); + expect(v[50] == 2028) catch @panic("test failure"); + expect(v[51] == 2029) catch @panic("test failure"); + expect(v[52] == 2030) catch @panic("test failure"); + expect(v[53] == 2031) catch @panic("test failure"); + expect(v[54] == 2032) catch @panic("test failure"); + expect(v[55] == 2033) catch @panic("test failure"); + expect(v[56] == 2034) catch @panic("test failure"); + expect(v[57] == 2035) catch @panic("test failure"); + expect(v[58] == 2036) catch @panic("test failure"); + expect(v[59] == 2037) catch @panic("test failure"); + expect(v[60] == 2038) catch @panic("test failure"); + expect(v[61] == 2039) catch @panic("test failure"); + expect(v[62] == 2040) catch @panic("test failure"); + expect(v[63] == 2041) catch @panic("test failure"); + expect(v[64] == 2042) catch @panic("test failure"); + expect(v[65] == 2043) catch @panic("test failure"); + expect(v[66] == 2044) catch @panic("test failure"); + expect(v[67] == 2045) catch @panic("test failure"); + expect(v[68] == 2046) catch @panic("test failure"); + expect(v[69] == 2047) catch @panic("test failure"); + expect(v[70] == 2048) catch @panic("test failure"); + expect(v[71] == 2049) catch @panic("test failure"); + expect(v[72] == 2050) catch @panic("test failure"); + expect(v[73] == 2051) catch @panic("test failure"); + expect(v[74] == 2052) catch @panic("test failure"); + expect(v[75] == 2053) catch @panic("test failure"); + expect(v[76] == 2054) catch @panic("test failure"); + expect(v[77] == 2055) catch @panic("test failure"); + expect(v[78] == 2056) catch @panic("test failure"); + expect(v[79] == 2057) catch @panic("test failure"); + expect(v[80] == 2058) catch @panic("test failure"); + expect(v[81] == 2059) catch @panic("test failure"); + expect(v[82] == 2060) catch @panic("test failure"); + expect(v[83] == 2061) catch @panic("test failure"); + expect(v[84] == 2062) catch @panic("test failure"); + expect(v[85] == 2063) catch @panic("test failure"); + expect(v[86] == 2064) catch @panic("test failure"); + expect(v[87] == 2065) catch @panic("test failure"); + expect(v[88] == 2066) catch @panic("test failure"); + expect(v[89] == 2067) catch @panic("test failure"); + expect(v[90] == 2068) catch @panic("test failure"); + expect(v[91] == 2069) catch @panic("test failure"); + expect(v[92] == 2070) catch @panic("test failure"); + expect(v[93] == 2071) catch @panic("test failure"); + expect(v[94] == 2072) catch @panic("test failure"); + expect(v[95] == 2073) catch @panic("test failure"); + expect(v[96] == 2074) catch @panic("test failure"); + expect(v[97] == 2075) catch @panic("test failure"); + expect(v[98] == 2076) catch @panic("test failure"); + expect(v[99] == 2077) catch @panic("test failure"); + expect(v[100] == 2078) catch @panic("test failure"); + expect(v[101] == 2079) catch @panic("test failure"); + expect(v[102] == 2080) catch @panic("test failure"); + expect(v[103] == 2081) catch @panic("test failure"); + expect(v[104] == 2082) catch @panic("test failure"); + expect(v[105] == 2083) catch @panic("test failure"); + expect(v[106] == 2084) catch @panic("test failure"); + expect(v[107] == 2085) catch @panic("test failure"); + expect(v[108] == 2086) catch @panic("test failure"); + expect(v[109] == 2087) catch @panic("test failure"); + expect(v[110] == 2088) catch @panic("test failure"); + expect(v[111] == 2089) catch @panic("test failure"); + expect(v[112] == 2090) catch @panic("test failure"); + expect(v[113] == 2091) catch @panic("test failure"); + expect(v[114] == 2092) catch @panic("test failure"); + expect(v[115] == 2093) catch @panic("test failure"); + expect(v[116] == 2094) catch @panic("test failure"); + expect(v[117] == 2095) catch @panic("test failure"); + expect(v[118] == 2096) catch @panic("test failure"); + expect(v[119] == 2097) catch @panic("test failure"); + expect(v[120] == 2098) catch @panic("test failure"); + expect(v[121] == 2099) catch @panic("test failure"); + expect(v[122] == 2100) catch @panic("test failure"); + expect(v[123] == 2101) catch @panic("test failure"); + expect(v[124] == 2102) catch @panic("test failure"); + expect(v[125] == 2103) catch @panic("test failure"); + expect(v[126] == 2104) catch @panic("test failure"); + expect(v[127] == 2105) catch @panic("test failure"); + expect(v[128] == 2106) catch @panic("test failure"); + expect(v[129] == 2107) catch @panic("test failure"); + expect(v[130] == 2108) catch @panic("test failure"); + expect(v[131] == 2109) catch @panic("test failure"); + expect(v[132] == 2110) catch @panic("test failure"); + expect(v[133] == 2111) catch @panic("test failure"); + expect(v[134] == 2112) catch @panic("test failure"); + expect(v[135] == 2113) catch @panic("test failure"); + expect(v[136] == 2114) catch @panic("test failure"); + expect(v[137] == 2115) catch @panic("test failure"); + expect(v[138] == 2116) catch @panic("test failure"); + expect(v[139] == 2117) catch @panic("test failure"); + expect(v[140] == 2118) catch @panic("test failure"); + expect(v[141] == 2119) catch @panic("test failure"); + expect(v[142] == 2120) catch @panic("test failure"); + expect(v[143] == 2121) catch @panic("test failure"); + expect(v[144] == 2122) catch @panic("test failure"); + expect(v[145] == 2123) catch @panic("test failure"); + expect(v[146] == 2124) catch @panic("test failure"); + expect(v[147] == 2125) catch @panic("test failure"); + expect(v[148] == 2126) catch @panic("test failure"); + expect(v[149] == 2127) catch @panic("test failure"); + expect(v[150] == 2128) catch @panic("test failure"); + expect(v[151] == 2129) catch @panic("test failure"); + expect(v[152] == 2130) catch @panic("test failure"); + expect(v[153] == 2131) catch @panic("test failure"); + expect(v[154] == 2132) catch @panic("test failure"); + expect(v[155] == 2133) catch @panic("test failure"); + expect(v[156] == 2134) catch @panic("test failure"); + expect(v[157] == 2135) catch @panic("test failure"); + expect(v[158] == 2136) catch @panic("test failure"); + expect(v[159] == 2137) catch @panic("test failure"); + expect(v[160] == 2138) catch @panic("test failure"); + expect(v[161] == 2139) catch @panic("test failure"); + expect(v[162] == 2140) catch @panic("test failure"); + expect(v[163] == 2141) catch @panic("test failure"); + expect(v[164] == 2142) catch @panic("test failure"); + expect(v[165] == 2143) catch @panic("test failure"); + expect(v[166] == 2144) catch @panic("test failure"); + expect(v[167] == 2145) catch @panic("test failure"); + expect(v[168] == 2146) catch @panic("test failure"); + expect(v[169] == 2147) catch @panic("test failure"); + expect(v[170] == 2148) catch @panic("test failure"); + expect(v[171] == 2149) catch @panic("test failure"); + expect(v[172] == 2150) catch @panic("test failure"); + expect(v[173] == 2151) catch @panic("test failure"); + expect(v[174] == 2152) catch @panic("test failure"); + expect(v[175] == 2153) catch @panic("test failure"); + expect(v[176] == 2154) catch @panic("test failure"); + expect(v[177] == 2155) catch @panic("test failure"); + expect(v[178] == 2156) catch @panic("test failure"); + expect(v[179] == 2157) catch @panic("test failure"); + expect(v[180] == 2158) catch @panic("test failure"); + expect(v[181] == 2159) catch @panic("test failure"); + expect(v[182] == 2160) catch @panic("test failure"); + expect(v[183] == 2161) catch @panic("test failure"); + expect(v[184] == 2162) catch @panic("test failure"); + expect(v[185] == 2163) catch @panic("test failure"); + expect(v[186] == 2164) catch @panic("test failure"); + expect(v[187] == 2165) catch @panic("test failure"); + expect(v[188] == 2166) catch @panic("test failure"); + expect(v[189] == 2167) catch @panic("test failure"); + expect(v[190] == 2168) catch @panic("test failure"); + expect(v[191] == 2169) catch @panic("test failure"); + expect(i == 192) catch @panic("test failure"); +} + +extern fn c_ret_vector_192_u16() @Vector(192, u16); +extern fn c_vector_192_u16(@Vector(192, u16), usize) void; +extern fn c_test_vector_192_u16() void; + +test "@Vector(192, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_192_u16(); + try expect(v[0] == 2170); + try expect(v[1] == 2171); + try expect(v[2] == 2172); + try expect(v[3] == 2173); + try expect(v[4] == 2174); + try expect(v[5] == 2175); + try expect(v[6] == 2176); + try expect(v[7] == 2177); + try expect(v[8] == 2178); + try expect(v[9] == 2179); + try expect(v[10] == 2180); + try expect(v[11] == 2181); + try expect(v[12] == 2182); + try expect(v[13] == 2183); + try expect(v[14] == 2184); + try expect(v[15] == 2185); + try expect(v[16] == 2186); + try expect(v[17] == 2187); + try expect(v[18] == 2188); + try expect(v[19] == 2189); + try expect(v[20] == 2190); + try expect(v[21] == 2191); + try expect(v[22] == 2192); + try expect(v[23] == 2193); + try expect(v[24] == 2194); + try expect(v[25] == 2195); + try expect(v[26] == 2196); + try expect(v[27] == 2197); + try expect(v[28] == 2198); + try expect(v[29] == 2199); + try expect(v[30] == 2200); + try expect(v[31] == 2201); + try expect(v[32] == 2202); + try expect(v[33] == 2203); + try expect(v[34] == 2204); + try expect(v[35] == 2205); + try expect(v[36] == 2206); + try expect(v[37] == 2207); + try expect(v[38] == 2208); + try expect(v[39] == 2209); + try expect(v[40] == 2210); + try expect(v[41] == 2211); + try expect(v[42] == 2212); + try expect(v[43] == 2213); + try expect(v[44] == 2214); + try expect(v[45] == 2215); + try expect(v[46] == 2216); + try expect(v[47] == 2217); + try expect(v[48] == 2218); + try expect(v[49] == 2219); + try expect(v[50] == 2220); + try expect(v[51] == 2221); + try expect(v[52] == 2222); + try expect(v[53] == 2223); + try expect(v[54] == 2224); + try expect(v[55] == 2225); + try expect(v[56] == 2226); + try expect(v[57] == 2227); + try expect(v[58] == 2228); + try expect(v[59] == 2229); + try expect(v[60] == 2230); + try expect(v[61] == 2231); + try expect(v[62] == 2232); + try expect(v[63] == 2233); + try expect(v[64] == 2234); + try expect(v[65] == 2235); + try expect(v[66] == 2236); + try expect(v[67] == 2237); + try expect(v[68] == 2238); + try expect(v[69] == 2239); + try expect(v[70] == 2240); + try expect(v[71] == 2241); + try expect(v[72] == 2242); + try expect(v[73] == 2243); + try expect(v[74] == 2244); + try expect(v[75] == 2245); + try expect(v[76] == 2246); + try expect(v[77] == 2247); + try expect(v[78] == 2248); + try expect(v[79] == 2249); + try expect(v[80] == 2250); + try expect(v[81] == 2251); + try expect(v[82] == 2252); + try expect(v[83] == 2253); + try expect(v[84] == 2254); + try expect(v[85] == 2255); + try expect(v[86] == 2256); + try expect(v[87] == 2257); + try expect(v[88] == 2258); + try expect(v[89] == 2259); + try expect(v[90] == 2260); + try expect(v[91] == 2261); + try expect(v[92] == 2262); + try expect(v[93] == 2263); + try expect(v[94] == 2264); + try expect(v[95] == 2265); + try expect(v[96] == 2266); + try expect(v[97] == 2267); + try expect(v[98] == 2268); + try expect(v[99] == 2269); + try expect(v[100] == 2270); + try expect(v[101] == 2271); + try expect(v[102] == 2272); + try expect(v[103] == 2273); + try expect(v[104] == 2274); + try expect(v[105] == 2275); + try expect(v[106] == 2276); + try expect(v[107] == 2277); + try expect(v[108] == 2278); + try expect(v[109] == 2279); + try expect(v[110] == 2280); + try expect(v[111] == 2281); + try expect(v[112] == 2282); + try expect(v[113] == 2283); + try expect(v[114] == 2284); + try expect(v[115] == 2285); + try expect(v[116] == 2286); + try expect(v[117] == 2287); + try expect(v[118] == 2288); + try expect(v[119] == 2289); + try expect(v[120] == 2290); + try expect(v[121] == 2291); + try expect(v[122] == 2292); + try expect(v[123] == 2293); + try expect(v[124] == 2294); + try expect(v[125] == 2295); + try expect(v[126] == 2296); + try expect(v[127] == 2297); + try expect(v[128] == 2298); + try expect(v[129] == 2299); + try expect(v[130] == 2300); + try expect(v[131] == 2301); + try expect(v[132] == 2302); + try expect(v[133] == 2303); + try expect(v[134] == 2304); + try expect(v[135] == 2305); + try expect(v[136] == 2306); + try expect(v[137] == 2307); + try expect(v[138] == 2308); + try expect(v[139] == 2309); + try expect(v[140] == 2310); + try expect(v[141] == 2311); + try expect(v[142] == 2312); + try expect(v[143] == 2313); + try expect(v[144] == 2314); + try expect(v[145] == 2315); + try expect(v[146] == 2316); + try expect(v[147] == 2317); + try expect(v[148] == 2318); + try expect(v[149] == 2319); + try expect(v[150] == 2320); + try expect(v[151] == 2321); + try expect(v[152] == 2322); + try expect(v[153] == 2323); + try expect(v[154] == 2324); + try expect(v[155] == 2325); + try expect(v[156] == 2326); + try expect(v[157] == 2327); + try expect(v[158] == 2328); + try expect(v[159] == 2329); + try expect(v[160] == 2330); + try expect(v[161] == 2331); + try expect(v[162] == 2332); + try expect(v[163] == 2333); + try expect(v[164] == 2334); + try expect(v[165] == 2335); + try expect(v[166] == 2336); + try expect(v[167] == 2337); + try expect(v[168] == 2338); + try expect(v[169] == 2339); + try expect(v[170] == 2340); + try expect(v[171] == 2341); + try expect(v[172] == 2342); + try expect(v[173] == 2343); + try expect(v[174] == 2344); + try expect(v[175] == 2345); + try expect(v[176] == 2346); + try expect(v[177] == 2347); + try expect(v[178] == 2348); + try expect(v[179] == 2349); + try expect(v[180] == 2350); + try expect(v[181] == 2351); + try expect(v[182] == 2352); + try expect(v[183] == 2353); + try expect(v[184] == 2354); + try expect(v[185] == 2355); + try expect(v[186] == 2356); + try expect(v[187] == 2357); + try expect(v[188] == 2358); + try expect(v[189] == 2359); + try expect(v[190] == 2360); + try expect(v[191] == 2361); + c_vector_192_u16(.{ + 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, + 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393, + 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, + 2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, + 2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, + 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, + 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473, + 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489, + 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, + 2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521, + 2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537, + 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, + }, 192); + c_test_vector_192_u16(); +} + +export fn zig_ret_vector_256_u16() @Vector(256, u16) { + return .{ + 2554, 2555, 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569, + 2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583, 2584, 2585, + 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, + 2602, 2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617, + 2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633, + 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, + 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665, + 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, 2679, 2680, 2681, + 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697, + 2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713, + 2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729, + 2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, + 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761, + 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777, + 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793, + 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, + }; +} +export fn zig_vector_256_u16(v: @Vector(256, u16), i: usize) void { + expect(v[0] == 2810) catch @panic("test failure"); + expect(v[1] == 2811) catch @panic("test failure"); + expect(v[2] == 2812) catch @panic("test failure"); + expect(v[3] == 2813) catch @panic("test failure"); + expect(v[4] == 2814) catch @panic("test failure"); + expect(v[5] == 2815) catch @panic("test failure"); + expect(v[6] == 2816) catch @panic("test failure"); + expect(v[7] == 2817) catch @panic("test failure"); + expect(v[8] == 2818) catch @panic("test failure"); + expect(v[9] == 2819) catch @panic("test failure"); + expect(v[10] == 2820) catch @panic("test failure"); + expect(v[11] == 2821) catch @panic("test failure"); + expect(v[12] == 2822) catch @panic("test failure"); + expect(v[13] == 2823) catch @panic("test failure"); + expect(v[14] == 2824) catch @panic("test failure"); + expect(v[15] == 2825) catch @panic("test failure"); + expect(v[16] == 2826) catch @panic("test failure"); + expect(v[17] == 2827) catch @panic("test failure"); + expect(v[18] == 2828) catch @panic("test failure"); + expect(v[19] == 2829) catch @panic("test failure"); + expect(v[20] == 2830) catch @panic("test failure"); + expect(v[21] == 2831) catch @panic("test failure"); + expect(v[22] == 2832) catch @panic("test failure"); + expect(v[23] == 2833) catch @panic("test failure"); + expect(v[24] == 2834) catch @panic("test failure"); + expect(v[25] == 2835) catch @panic("test failure"); + expect(v[26] == 2836) catch @panic("test failure"); + expect(v[27] == 2837) catch @panic("test failure"); + expect(v[28] == 2838) catch @panic("test failure"); + expect(v[29] == 2839) catch @panic("test failure"); + expect(v[30] == 2840) catch @panic("test failure"); + expect(v[31] == 2841) catch @panic("test failure"); + expect(v[32] == 2842) catch @panic("test failure"); + expect(v[33] == 2843) catch @panic("test failure"); + expect(v[34] == 2844) catch @panic("test failure"); + expect(v[35] == 2845) catch @panic("test failure"); + expect(v[36] == 2846) catch @panic("test failure"); + expect(v[37] == 2847) catch @panic("test failure"); + expect(v[38] == 2848) catch @panic("test failure"); + expect(v[39] == 2849) catch @panic("test failure"); + expect(v[40] == 2850) catch @panic("test failure"); + expect(v[41] == 2851) catch @panic("test failure"); + expect(v[42] == 2852) catch @panic("test failure"); + expect(v[43] == 2853) catch @panic("test failure"); + expect(v[44] == 2854) catch @panic("test failure"); + expect(v[45] == 2855) catch @panic("test failure"); + expect(v[46] == 2856) catch @panic("test failure"); + expect(v[47] == 2857) catch @panic("test failure"); + expect(v[48] == 2858) catch @panic("test failure"); + expect(v[49] == 2859) catch @panic("test failure"); + expect(v[50] == 2860) catch @panic("test failure"); + expect(v[51] == 2861) catch @panic("test failure"); + expect(v[52] == 2862) catch @panic("test failure"); + expect(v[53] == 2863) catch @panic("test failure"); + expect(v[54] == 2864) catch @panic("test failure"); + expect(v[55] == 2865) catch @panic("test failure"); + expect(v[56] == 2866) catch @panic("test failure"); + expect(v[57] == 2867) catch @panic("test failure"); + expect(v[58] == 2868) catch @panic("test failure"); + expect(v[59] == 2869) catch @panic("test failure"); + expect(v[60] == 2870) catch @panic("test failure"); + expect(v[61] == 2871) catch @panic("test failure"); + expect(v[62] == 2872) catch @panic("test failure"); + expect(v[63] == 2873) catch @panic("test failure"); + expect(v[64] == 2874) catch @panic("test failure"); + expect(v[65] == 2875) catch @panic("test failure"); + expect(v[66] == 2876) catch @panic("test failure"); + expect(v[67] == 2877) catch @panic("test failure"); + expect(v[68] == 2878) catch @panic("test failure"); + expect(v[69] == 2879) catch @panic("test failure"); + expect(v[70] == 2880) catch @panic("test failure"); + expect(v[71] == 2881) catch @panic("test failure"); + expect(v[72] == 2882) catch @panic("test failure"); + expect(v[73] == 2883) catch @panic("test failure"); + expect(v[74] == 2884) catch @panic("test failure"); + expect(v[75] == 2885) catch @panic("test failure"); + expect(v[76] == 2886) catch @panic("test failure"); + expect(v[77] == 2887) catch @panic("test failure"); + expect(v[78] == 2888) catch @panic("test failure"); + expect(v[79] == 2889) catch @panic("test failure"); + expect(v[80] == 2890) catch @panic("test failure"); + expect(v[81] == 2891) catch @panic("test failure"); + expect(v[82] == 2892) catch @panic("test failure"); + expect(v[83] == 2893) catch @panic("test failure"); + expect(v[84] == 2894) catch @panic("test failure"); + expect(v[85] == 2895) catch @panic("test failure"); + expect(v[86] == 2896) catch @panic("test failure"); + expect(v[87] == 2897) catch @panic("test failure"); + expect(v[88] == 2898) catch @panic("test failure"); + expect(v[89] == 2899) catch @panic("test failure"); + expect(v[90] == 2900) catch @panic("test failure"); + expect(v[91] == 2901) catch @panic("test failure"); + expect(v[92] == 2902) catch @panic("test failure"); + expect(v[93] == 2903) catch @panic("test failure"); + expect(v[94] == 2904) catch @panic("test failure"); + expect(v[95] == 2905) catch @panic("test failure"); + expect(v[96] == 2906) catch @panic("test failure"); + expect(v[97] == 2907) catch @panic("test failure"); + expect(v[98] == 2908) catch @panic("test failure"); + expect(v[99] == 2909) catch @panic("test failure"); + expect(v[100] == 2910) catch @panic("test failure"); + expect(v[101] == 2911) catch @panic("test failure"); + expect(v[102] == 2912) catch @panic("test failure"); + expect(v[103] == 2913) catch @panic("test failure"); + expect(v[104] == 2914) catch @panic("test failure"); + expect(v[105] == 2915) catch @panic("test failure"); + expect(v[106] == 2916) catch @panic("test failure"); + expect(v[107] == 2917) catch @panic("test failure"); + expect(v[108] == 2918) catch @panic("test failure"); + expect(v[109] == 2919) catch @panic("test failure"); + expect(v[110] == 2920) catch @panic("test failure"); + expect(v[111] == 2921) catch @panic("test failure"); + expect(v[112] == 2922) catch @panic("test failure"); + expect(v[113] == 2923) catch @panic("test failure"); + expect(v[114] == 2924) catch @panic("test failure"); + expect(v[115] == 2925) catch @panic("test failure"); + expect(v[116] == 2926) catch @panic("test failure"); + expect(v[117] == 2927) catch @panic("test failure"); + expect(v[118] == 2928) catch @panic("test failure"); + expect(v[119] == 2929) catch @panic("test failure"); + expect(v[120] == 2930) catch @panic("test failure"); + expect(v[121] == 2931) catch @panic("test failure"); + expect(v[122] == 2932) catch @panic("test failure"); + expect(v[123] == 2933) catch @panic("test failure"); + expect(v[124] == 2934) catch @panic("test failure"); + expect(v[125] == 2935) catch @panic("test failure"); + expect(v[126] == 2936) catch @panic("test failure"); + expect(v[127] == 2937) catch @panic("test failure"); + expect(v[128] == 2938) catch @panic("test failure"); + expect(v[129] == 2939) catch @panic("test failure"); + expect(v[130] == 2940) catch @panic("test failure"); + expect(v[131] == 2941) catch @panic("test failure"); + expect(v[132] == 2942) catch @panic("test failure"); + expect(v[133] == 2943) catch @panic("test failure"); + expect(v[134] == 2944) catch @panic("test failure"); + expect(v[135] == 2945) catch @panic("test failure"); + expect(v[136] == 2946) catch @panic("test failure"); + expect(v[137] == 2947) catch @panic("test failure"); + expect(v[138] == 2948) catch @panic("test failure"); + expect(v[139] == 2949) catch @panic("test failure"); + expect(v[140] == 2950) catch @panic("test failure"); + expect(v[141] == 2951) catch @panic("test failure"); + expect(v[142] == 2952) catch @panic("test failure"); + expect(v[143] == 2953) catch @panic("test failure"); + expect(v[144] == 2954) catch @panic("test failure"); + expect(v[145] == 2955) catch @panic("test failure"); + expect(v[146] == 2956) catch @panic("test failure"); + expect(v[147] == 2957) catch @panic("test failure"); + expect(v[148] == 2958) catch @panic("test failure"); + expect(v[149] == 2959) catch @panic("test failure"); + expect(v[150] == 2960) catch @panic("test failure"); + expect(v[151] == 2961) catch @panic("test failure"); + expect(v[152] == 2962) catch @panic("test failure"); + expect(v[153] == 2963) catch @panic("test failure"); + expect(v[154] == 2964) catch @panic("test failure"); + expect(v[155] == 2965) catch @panic("test failure"); + expect(v[156] == 2966) catch @panic("test failure"); + expect(v[157] == 2967) catch @panic("test failure"); + expect(v[158] == 2968) catch @panic("test failure"); + expect(v[159] == 2969) catch @panic("test failure"); + expect(v[160] == 2970) catch @panic("test failure"); + expect(v[161] == 2971) catch @panic("test failure"); + expect(v[162] == 2972) catch @panic("test failure"); + expect(v[163] == 2973) catch @panic("test failure"); + expect(v[164] == 2974) catch @panic("test failure"); + expect(v[165] == 2975) catch @panic("test failure"); + expect(v[166] == 2976) catch @panic("test failure"); + expect(v[167] == 2977) catch @panic("test failure"); + expect(v[168] == 2978) catch @panic("test failure"); + expect(v[169] == 2979) catch @panic("test failure"); + expect(v[170] == 2980) catch @panic("test failure"); + expect(v[171] == 2981) catch @panic("test failure"); + expect(v[172] == 2982) catch @panic("test failure"); + expect(v[173] == 2983) catch @panic("test failure"); + expect(v[174] == 2984) catch @panic("test failure"); + expect(v[175] == 2985) catch @panic("test failure"); + expect(v[176] == 2986) catch @panic("test failure"); + expect(v[177] == 2987) catch @panic("test failure"); + expect(v[178] == 2988) catch @panic("test failure"); + expect(v[179] == 2989) catch @panic("test failure"); + expect(v[180] == 2990) catch @panic("test failure"); + expect(v[181] == 2991) catch @panic("test failure"); + expect(v[182] == 2992) catch @panic("test failure"); + expect(v[183] == 2993) catch @panic("test failure"); + expect(v[184] == 2994) catch @panic("test failure"); + expect(v[185] == 2995) catch @panic("test failure"); + expect(v[186] == 2996) catch @panic("test failure"); + expect(v[187] == 2997) catch @panic("test failure"); + expect(v[188] == 2998) catch @panic("test failure"); + expect(v[189] == 2999) catch @panic("test failure"); + expect(v[190] == 3000) catch @panic("test failure"); + expect(v[191] == 3001) catch @panic("test failure"); + expect(v[192] == 3002) catch @panic("test failure"); + expect(v[193] == 3003) catch @panic("test failure"); + expect(v[194] == 3004) catch @panic("test failure"); + expect(v[195] == 3005) catch @panic("test failure"); + expect(v[196] == 3006) catch @panic("test failure"); + expect(v[197] == 3007) catch @panic("test failure"); + expect(v[198] == 3008) catch @panic("test failure"); + expect(v[199] == 3009) catch @panic("test failure"); + expect(v[200] == 3010) catch @panic("test failure"); + expect(v[201] == 3011) catch @panic("test failure"); + expect(v[202] == 3012) catch @panic("test failure"); + expect(v[203] == 3013) catch @panic("test failure"); + expect(v[204] == 3014) catch @panic("test failure"); + expect(v[205] == 3015) catch @panic("test failure"); + expect(v[206] == 3016) catch @panic("test failure"); + expect(v[207] == 3017) catch @panic("test failure"); + expect(v[208] == 3018) catch @panic("test failure"); + expect(v[209] == 3019) catch @panic("test failure"); + expect(v[210] == 3020) catch @panic("test failure"); + expect(v[211] == 3021) catch @panic("test failure"); + expect(v[212] == 3022) catch @panic("test failure"); + expect(v[213] == 3023) catch @panic("test failure"); + expect(v[214] == 3024) catch @panic("test failure"); + expect(v[215] == 3025) catch @panic("test failure"); + expect(v[216] == 3026) catch @panic("test failure"); + expect(v[217] == 3027) catch @panic("test failure"); + expect(v[218] == 3028) catch @panic("test failure"); + expect(v[219] == 3029) catch @panic("test failure"); + expect(v[220] == 3030) catch @panic("test failure"); + expect(v[221] == 3031) catch @panic("test failure"); + expect(v[222] == 3032) catch @panic("test failure"); + expect(v[223] == 3033) catch @panic("test failure"); + expect(v[224] == 3034) catch @panic("test failure"); + expect(v[225] == 3035) catch @panic("test failure"); + expect(v[226] == 3036) catch @panic("test failure"); + expect(v[227] == 3037) catch @panic("test failure"); + expect(v[228] == 3038) catch @panic("test failure"); + expect(v[229] == 3039) catch @panic("test failure"); + expect(v[230] == 3040) catch @panic("test failure"); + expect(v[231] == 3041) catch @panic("test failure"); + expect(v[232] == 3042) catch @panic("test failure"); + expect(v[233] == 3043) catch @panic("test failure"); + expect(v[234] == 3044) catch @panic("test failure"); + expect(v[235] == 3045) catch @panic("test failure"); + expect(v[236] == 3046) catch @panic("test failure"); + expect(v[237] == 3047) catch @panic("test failure"); + expect(v[238] == 3048) catch @panic("test failure"); + expect(v[239] == 3049) catch @panic("test failure"); + expect(v[240] == 3050) catch @panic("test failure"); + expect(v[241] == 3051) catch @panic("test failure"); + expect(v[242] == 3052) catch @panic("test failure"); + expect(v[243] == 3053) catch @panic("test failure"); + expect(v[244] == 3054) catch @panic("test failure"); + expect(v[245] == 3055) catch @panic("test failure"); + expect(v[246] == 3056) catch @panic("test failure"); + expect(v[247] == 3057) catch @panic("test failure"); + expect(v[248] == 3058) catch @panic("test failure"); + expect(v[249] == 3059) catch @panic("test failure"); + expect(v[250] == 3060) catch @panic("test failure"); + expect(v[251] == 3061) catch @panic("test failure"); + expect(v[252] == 3062) catch @panic("test failure"); + expect(v[253] == 3063) catch @panic("test failure"); + expect(v[254] == 3064) catch @panic("test failure"); + expect(v[255] == 3065) catch @panic("test failure"); + expect(i == 256) catch @panic("test failure"); +} + +extern fn c_ret_vector_256_u16() @Vector(256, u16); +extern fn c_vector_256_u16(@Vector(256, u16), usize) void; +extern fn c_test_vector_256_u16() void; + +test "@Vector(256, u16)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_256_u16(); + try expect(v[0] == 3066); + try expect(v[1] == 3067); + try expect(v[2] == 3068); + try expect(v[3] == 3069); + try expect(v[4] == 3070); + try expect(v[5] == 3071); + try expect(v[6] == 3072); + try expect(v[7] == 3073); + try expect(v[8] == 3074); + try expect(v[9] == 3075); + try expect(v[10] == 3076); + try expect(v[11] == 3077); + try expect(v[12] == 3078); + try expect(v[13] == 3079); + try expect(v[14] == 3080); + try expect(v[15] == 3081); + try expect(v[16] == 3082); + try expect(v[17] == 3083); + try expect(v[18] == 3084); + try expect(v[19] == 3085); + try expect(v[20] == 3086); + try expect(v[21] == 3087); + try expect(v[22] == 3088); + try expect(v[23] == 3089); + try expect(v[24] == 3090); + try expect(v[25] == 3091); + try expect(v[26] == 3092); + try expect(v[27] == 3093); + try expect(v[28] == 3094); + try expect(v[29] == 3095); + try expect(v[30] == 3096); + try expect(v[31] == 3097); + try expect(v[32] == 3098); + try expect(v[33] == 3099); + try expect(v[34] == 3100); + try expect(v[35] == 3101); + try expect(v[36] == 3102); + try expect(v[37] == 3103); + try expect(v[38] == 3104); + try expect(v[39] == 3105); + try expect(v[40] == 3106); + try expect(v[41] == 3107); + try expect(v[42] == 3108); + try expect(v[43] == 3109); + try expect(v[44] == 3110); + try expect(v[45] == 3111); + try expect(v[46] == 3112); + try expect(v[47] == 3113); + try expect(v[48] == 3114); + try expect(v[49] == 3115); + try expect(v[50] == 3116); + try expect(v[51] == 3117); + try expect(v[52] == 3118); + try expect(v[53] == 3119); + try expect(v[54] == 3120); + try expect(v[55] == 3121); + try expect(v[56] == 3122); + try expect(v[57] == 3123); + try expect(v[58] == 3124); + try expect(v[59] == 3125); + try expect(v[60] == 3126); + try expect(v[61] == 3127); + try expect(v[62] == 3128); + try expect(v[63] == 3129); + try expect(v[64] == 3130); + try expect(v[65] == 3131); + try expect(v[66] == 3132); + try expect(v[67] == 3133); + try expect(v[68] == 3134); + try expect(v[69] == 3135); + try expect(v[70] == 3136); + try expect(v[71] == 3137); + try expect(v[72] == 3138); + try expect(v[73] == 3139); + try expect(v[74] == 3140); + try expect(v[75] == 3141); + try expect(v[76] == 3142); + try expect(v[77] == 3143); + try expect(v[78] == 3144); + try expect(v[79] == 3145); + try expect(v[80] == 3146); + try expect(v[81] == 3147); + try expect(v[82] == 3148); + try expect(v[83] == 3149); + try expect(v[84] == 3150); + try expect(v[85] == 3151); + try expect(v[86] == 3152); + try expect(v[87] == 3153); + try expect(v[88] == 3154); + try expect(v[89] == 3155); + try expect(v[90] == 3156); + try expect(v[91] == 3157); + try expect(v[92] == 3158); + try expect(v[93] == 3159); + try expect(v[94] == 3160); + try expect(v[95] == 3161); + try expect(v[96] == 3162); + try expect(v[97] == 3163); + try expect(v[98] == 3164); + try expect(v[99] == 3165); + try expect(v[100] == 3166); + try expect(v[101] == 3167); + try expect(v[102] == 3168); + try expect(v[103] == 3169); + try expect(v[104] == 3170); + try expect(v[105] == 3171); + try expect(v[106] == 3172); + try expect(v[107] == 3173); + try expect(v[108] == 3174); + try expect(v[109] == 3175); + try expect(v[110] == 3176); + try expect(v[111] == 3177); + try expect(v[112] == 3178); + try expect(v[113] == 3179); + try expect(v[114] == 3180); + try expect(v[115] == 3181); + try expect(v[116] == 3182); + try expect(v[117] == 3183); + try expect(v[118] == 3184); + try expect(v[119] == 3185); + try expect(v[120] == 3186); + try expect(v[121] == 3187); + try expect(v[122] == 3188); + try expect(v[123] == 3189); + try expect(v[124] == 3190); + try expect(v[125] == 3191); + try expect(v[126] == 3192); + try expect(v[127] == 3193); + try expect(v[128] == 3194); + try expect(v[129] == 3195); + try expect(v[130] == 3196); + try expect(v[131] == 3197); + try expect(v[132] == 3198); + try expect(v[133] == 3199); + try expect(v[134] == 3200); + try expect(v[135] == 3201); + try expect(v[136] == 3202); + try expect(v[137] == 3203); + try expect(v[138] == 3204); + try expect(v[139] == 3205); + try expect(v[140] == 3206); + try expect(v[141] == 3207); + try expect(v[142] == 3208); + try expect(v[143] == 3209); + try expect(v[144] == 3210); + try expect(v[145] == 3211); + try expect(v[146] == 3212); + try expect(v[147] == 3213); + try expect(v[148] == 3214); + try expect(v[149] == 3215); + try expect(v[150] == 3216); + try expect(v[151] == 3217); + try expect(v[152] == 3218); + try expect(v[153] == 3219); + try expect(v[154] == 3220); + try expect(v[155] == 3221); + try expect(v[156] == 3222); + try expect(v[157] == 3223); + try expect(v[158] == 3224); + try expect(v[159] == 3225); + try expect(v[160] == 3226); + try expect(v[161] == 3227); + try expect(v[162] == 3228); + try expect(v[163] == 3229); + try expect(v[164] == 3230); + try expect(v[165] == 3231); + try expect(v[166] == 3232); + try expect(v[167] == 3233); + try expect(v[168] == 3234); + try expect(v[169] == 3235); + try expect(v[170] == 3236); + try expect(v[171] == 3237); + try expect(v[172] == 3238); + try expect(v[173] == 3239); + try expect(v[174] == 3240); + try expect(v[175] == 3241); + try expect(v[176] == 3242); + try expect(v[177] == 3243); + try expect(v[178] == 3244); + try expect(v[179] == 3245); + try expect(v[180] == 3246); + try expect(v[181] == 3247); + try expect(v[182] == 3248); + try expect(v[183] == 3249); + try expect(v[184] == 3250); + try expect(v[185] == 3251); + try expect(v[186] == 3252); + try expect(v[187] == 3253); + try expect(v[188] == 3254); + try expect(v[189] == 3255); + try expect(v[190] == 3256); + try expect(v[191] == 3257); + try expect(v[192] == 3258); + try expect(v[193] == 3259); + try expect(v[194] == 3260); + try expect(v[195] == 3261); + try expect(v[196] == 3262); + try expect(v[197] == 3263); + try expect(v[198] == 3264); + try expect(v[199] == 3265); + try expect(v[200] == 3266); + try expect(v[201] == 3267); + try expect(v[202] == 3268); + try expect(v[203] == 3269); + try expect(v[204] == 3270); + try expect(v[205] == 3271); + try expect(v[206] == 3272); + try expect(v[207] == 3273); + try expect(v[208] == 3274); + try expect(v[209] == 3275); + try expect(v[210] == 3276); + try expect(v[211] == 3277); + try expect(v[212] == 3278); + try expect(v[213] == 3279); + try expect(v[214] == 3280); + try expect(v[215] == 3281); + try expect(v[216] == 3282); + try expect(v[217] == 3283); + try expect(v[218] == 3284); + try expect(v[219] == 3285); + try expect(v[220] == 3286); + try expect(v[221] == 3287); + try expect(v[222] == 3288); + try expect(v[223] == 3289); + try expect(v[224] == 3290); + try expect(v[225] == 3291); + try expect(v[226] == 3292); + try expect(v[227] == 3293); + try expect(v[228] == 3294); + try expect(v[229] == 3295); + try expect(v[230] == 3296); + try expect(v[231] == 3297); + try expect(v[232] == 3298); + try expect(v[233] == 3299); + try expect(v[234] == 3300); + try expect(v[235] == 3301); + try expect(v[236] == 3302); + try expect(v[237] == 3303); + try expect(v[238] == 3304); + try expect(v[239] == 3305); + try expect(v[240] == 3306); + try expect(v[241] == 3307); + try expect(v[242] == 3308); + try expect(v[243] == 3309); + try expect(v[244] == 3310); + try expect(v[245] == 3311); + try expect(v[246] == 3312); + try expect(v[247] == 3313); + try expect(v[248] == 3314); + try expect(v[249] == 3315); + try expect(v[250] == 3316); + try expect(v[251] == 3317); + try expect(v[252] == 3318); + try expect(v[253] == 3319); + try expect(v[254] == 3320); + try expect(v[255] == 3321); + c_vector_256_u16(.{ + 3322, 3323, 3324, 3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336, 3337, + 3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348, 3349, 3350, 3351, 3352, 3353, + 3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369, + 3370, 3371, 3372, 3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385, + 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, 3401, + 3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417, + 3418, 3419, 3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433, + 3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448, 3449, + 3450, 3451, 3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, 3461, 3462, 3463, 3464, 3465, + 3466, 3467, 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3481, + 3482, 3483, 3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, 3493, 3494, 3495, 3496, 3497, + 3498, 3499, 3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513, + 3514, 3515, 3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526, 3527, 3528, 3529, + 3530, 3531, 3532, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 3544, 3545, + 3546, 3547, 3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 3556, 3557, 3558, 3559, 3560, 3561, + 3562, 3563, 3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574, 3575, 3576, 3577, + }, 256); + c_test_vector_256_u16(); +} + +export fn zig_ret_vector_1_u32() @Vector(1, u32) { + return .{1}; +} +export fn zig_vector_1_u32(v: @Vector(1, u32), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_u32() @Vector(1, u32); +extern fn c_vector_1_u32(@Vector(1, u32), usize) void; +extern fn c_test_vector_1_u32() void; + +test "@Vector(1, u32)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + + const v = c_ret_vector_1_u32(); + try expect(v[0] == 3); + c_vector_1_u32(.{4}, 1); + c_test_vector_1_u32(); +} + +export fn zig_ret_vector_2_u32() @Vector(2, u32) { + return .{ 5, 6 }; +} +export fn zig_vector_2_u32(v: @Vector(2, u32), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_u32() @Vector(2, u32); +extern fn c_vector_2_u32(@Vector(2, u32), usize) void; +extern fn c_test_vector_2_u32() void; + +test "@Vector(2, u32)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const v = c_ret_vector_2_u32(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_u32(.{ 11, 12 }, 2); + c_test_vector_2_u32(); +} + +export fn zig_ret_vector_3_u32() @Vector(3, u32) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_u32(v: @Vector(3, u32), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_u32() @Vector(3, u32); +extern fn c_vector_3_u32(@Vector(3, u32), usize) void; +extern fn c_test_vector_3_u32() void; + +test "@Vector(3, u32)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + + const v = c_ret_vector_3_u32(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_u32(.{ 22, 23, 24 }, 3); + c_test_vector_3_u32(); +} + +export fn zig_ret_vector_4_u32() @Vector(4, u32) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_u32(v: @Vector(4, u32), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} +export fn zig_vector_4_u32_vector_4_u32(v0: @Vector(4, u32), v1: @Vector(4, u32), i: usize) void { + expect(v0[0] == 33) catch @panic("test failure"); + expect(v0[1] == 34) catch @panic("test failure"); + expect(v0[2] == 35) catch @panic("test failure"); + expect(v0[3] == 36) catch @panic("test failure"); + expect(v1[0] == 37) catch @panic("test failure"); + expect(v1[1] == 38) catch @panic("test failure"); + expect(v1[2] == 39) catch @panic("test failure"); + expect(v1[3] == 40) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_4_u32() @Vector(4, u32); +extern fn c_vector_4_u32(@Vector(4, u32), usize) void; +extern fn c_vector_4_u32_vector_4_u32(@Vector(4, u32), @Vector(4, u32), usize) void; +extern fn c_test_vector_4_u32() void; + +test "@Vector(4, u32)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_4_u32(); + try expect(v[0] == 41); + try expect(v[1] == 42); + try expect(v[2] == 43); + try expect(v[3] == 44); + c_vector_4_u32(.{ 45, 46, 47, 48 }, 4); + c_vector_4_u32_vector_4_u32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8); + c_test_vector_4_u32(); +} + +export fn zig_ret_vector_6_u32() @Vector(6, u32) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_u32(v: @Vector(6, u32), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_u32() @Vector(6, u32); +extern fn c_vector_6_u32(@Vector(6, u32), usize) void; +extern fn c_test_vector_6_u32() void; + +test "@Vector(6, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_6_u32(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_u32(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_u32(); +} + +export fn zig_ret_vector_8_u32() @Vector(8, u32) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_u32(v: @Vector(8, u32), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_u32() @Vector(8, u32); +extern fn c_vector_8_u32(@Vector(8, u32), usize) void; +extern fn c_test_vector_8_u32() void; + +test "@Vector(8, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_8_u32(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_u32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_u32(); +} + +export fn zig_ret_vector_12_u32() @Vector(12, u32) { + return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 }; +} +export fn zig_vector_12_u32(v: @Vector(12, u32), i: usize) void { + expect(v[0] == 109) catch @panic("test failure"); + expect(v[1] == 110) catch @panic("test failure"); + expect(v[2] == 111) catch @panic("test failure"); + expect(v[3] == 112) catch @panic("test failure"); + expect(v[4] == 113) catch @panic("test failure"); + expect(v[5] == 114) catch @panic("test failure"); + expect(v[6] == 115) catch @panic("test failure"); + expect(v[7] == 116) catch @panic("test failure"); + expect(v[8] == 117) catch @panic("test failure"); + expect(v[9] == 118) catch @panic("test failure"); + expect(v[10] == 119) catch @panic("test failure"); + expect(v[11] == 120) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_u32() @Vector(12, u32); +extern fn c_vector_12_u32(@Vector(12, u32), usize) void; +extern fn c_test_vector_12_u32() void; + +test "@Vector(12, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_12_u32(); + try expect(v[0] == 121); + try expect(v[1] == 122); + try expect(v[2] == 123); + try expect(v[3] == 124); + try expect(v[4] == 125); + try expect(v[5] == 126); + try expect(v[6] == 127); + try expect(v[7] == 128); + try expect(v[8] == 129); + try expect(v[9] == 130); + try expect(v[10] == 131); + try expect(v[11] == 132); + c_vector_12_u32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12); + c_test_vector_12_u32(); +} + +export fn zig_ret_vector_16_u32() @Vector(16, u32) { + return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 }; +} +export fn zig_vector_16_u32(v: @Vector(16, u32), i: usize) void { + expect(v[0] == 161) catch @panic("test failure"); + expect(v[1] == 162) catch @panic("test failure"); + expect(v[2] == 163) catch @panic("test failure"); + expect(v[3] == 164) catch @panic("test failure"); + expect(v[4] == 165) catch @panic("test failure"); + expect(v[5] == 166) catch @panic("test failure"); + expect(v[6] == 167) catch @panic("test failure"); + expect(v[7] == 168) catch @panic("test failure"); + expect(v[8] == 169) catch @panic("test failure"); + expect(v[9] == 170) catch @panic("test failure"); + expect(v[10] == 171) catch @panic("test failure"); + expect(v[11] == 172) catch @panic("test failure"); + expect(v[12] == 173) catch @panic("test failure"); + expect(v[13] == 174) catch @panic("test failure"); + expect(v[14] == 175) catch @panic("test failure"); + expect(v[15] == 176) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_u32() @Vector(16, u32); +extern fn c_vector_16_u32(@Vector(16, u32), usize) void; +extern fn c_test_vector_16_u32() void; + +test "@Vector(16, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_16_u32(); + try expect(v[0] == 177); + try expect(v[1] == 178); + try expect(v[2] == 179); + try expect(v[3] == 180); + try expect(v[4] == 181); + try expect(v[5] == 182); + try expect(v[6] == 183); + try expect(v[7] == 184); + try expect(v[8] == 185); + try expect(v[9] == 186); + try expect(v[10] == 187); + try expect(v[11] == 188); + try expect(v[12] == 189); + try expect(v[13] == 190); + try expect(v[14] == 191); + try expect(v[15] == 192); + c_vector_16_u32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16); + c_test_vector_16_u32(); +} + +export fn zig_ret_vector_24_u32() @Vector(24, u32) { + return .{ + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, + }; +} +export fn zig_vector_24_u32(v: @Vector(24, u32), i: usize) void { + expect(v[0] == 233) catch @panic("test failure"); + expect(v[1] == 234) catch @panic("test failure"); + expect(v[2] == 235) catch @panic("test failure"); + expect(v[3] == 236) catch @panic("test failure"); + expect(v[4] == 237) catch @panic("test failure"); + expect(v[5] == 238) catch @panic("test failure"); + expect(v[6] == 239) catch @panic("test failure"); + expect(v[7] == 240) catch @panic("test failure"); + expect(v[8] == 241) catch @panic("test failure"); + expect(v[9] == 242) catch @panic("test failure"); + expect(v[10] == 243) catch @panic("test failure"); + expect(v[11] == 244) catch @panic("test failure"); + expect(v[12] == 245) catch @panic("test failure"); + expect(v[13] == 246) catch @panic("test failure"); + expect(v[14] == 247) catch @panic("test failure"); + expect(v[15] == 248) catch @panic("test failure"); + expect(v[16] == 249) catch @panic("test failure"); + expect(v[17] == 250) catch @panic("test failure"); + expect(v[18] == 251) catch @panic("test failure"); + expect(v[19] == 252) catch @panic("test failure"); + expect(v[20] == 253) catch @panic("test failure"); + expect(v[21] == 254) catch @panic("test failure"); + expect(v[22] == 255) catch @panic("test failure"); + expect(v[23] == 256) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_u32() @Vector(24, u32); +extern fn c_vector_24_u32(@Vector(24, u32), usize) void; +extern fn c_test_vector_24_u32() void; + +test "@Vector(24, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_24_u32(); + try expect(v[0] == 257); + try expect(v[1] == 258); + try expect(v[2] == 259); + try expect(v[3] == 260); + try expect(v[4] == 261); + try expect(v[5] == 262); + try expect(v[6] == 263); + try expect(v[7] == 264); + try expect(v[8] == 265); + try expect(v[9] == 266); + try expect(v[10] == 267); + try expect(v[11] == 268); + try expect(v[12] == 269); + try expect(v[13] == 270); + try expect(v[14] == 271); + try expect(v[15] == 272); + try expect(v[16] == 273); + try expect(v[17] == 274); + try expect(v[18] == 275); + try expect(v[19] == 276); + try expect(v[20] == 277); + try expect(v[21] == 278); + try expect(v[22] == 279); + try expect(v[23] == 280); + c_vector_24_u32(.{ + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, + }, 24); + c_test_vector_24_u32(); +} + +export fn zig_ret_vector_32_u32() @Vector(32, u32) { + return .{ + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + }; +} +export fn zig_vector_32_u32(v: @Vector(32, u32), i: usize) void { + expect(v[0] == 337) catch @panic("test failure"); + expect(v[1] == 338) catch @panic("test failure"); + expect(v[2] == 339) catch @panic("test failure"); + expect(v[3] == 340) catch @panic("test failure"); + expect(v[4] == 341) catch @panic("test failure"); + expect(v[5] == 342) catch @panic("test failure"); + expect(v[6] == 343) catch @panic("test failure"); + expect(v[7] == 344) catch @panic("test failure"); + expect(v[8] == 345) catch @panic("test failure"); + expect(v[9] == 346) catch @panic("test failure"); + expect(v[10] == 347) catch @panic("test failure"); + expect(v[11] == 348) catch @panic("test failure"); + expect(v[12] == 349) catch @panic("test failure"); + expect(v[13] == 350) catch @panic("test failure"); + expect(v[14] == 351) catch @panic("test failure"); + expect(v[15] == 352) catch @panic("test failure"); + expect(v[16] == 353) catch @panic("test failure"); + expect(v[17] == 354) catch @panic("test failure"); + expect(v[18] == 355) catch @panic("test failure"); + expect(v[19] == 356) catch @panic("test failure"); + expect(v[20] == 357) catch @panic("test failure"); + expect(v[21] == 358) catch @panic("test failure"); + expect(v[22] == 359) catch @panic("test failure"); + expect(v[23] == 360) catch @panic("test failure"); + expect(v[24] == 361) catch @panic("test failure"); + expect(v[25] == 362) catch @panic("test failure"); + expect(v[26] == 363) catch @panic("test failure"); + expect(v[27] == 364) catch @panic("test failure"); + expect(v[28] == 365) catch @panic("test failure"); + expect(v[29] == 366) catch @panic("test failure"); + expect(v[30] == 367) catch @panic("test failure"); + expect(v[31] == 368) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_u32() @Vector(32, u32); +extern fn c_vector_32_u32(@Vector(32, u32), usize) void; +extern fn c_test_vector_32_u32() void; + +test "@Vector(32, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_u32(); + try expect(v[0] == 369); + try expect(v[1] == 370); + try expect(v[2] == 371); + try expect(v[3] == 372); + try expect(v[4] == 373); + try expect(v[5] == 374); + try expect(v[6] == 375); + try expect(v[7] == 376); + try expect(v[8] == 377); + try expect(v[9] == 378); + try expect(v[10] == 379); + try expect(v[11] == 380); + try expect(v[12] == 381); + try expect(v[13] == 382); + try expect(v[14] == 383); + try expect(v[15] == 384); + try expect(v[16] == 385); + try expect(v[17] == 386); + try expect(v[18] == 387); + try expect(v[19] == 388); + try expect(v[20] == 389); + try expect(v[21] == 390); + try expect(v[22] == 391); + try expect(v[23] == 392); + try expect(v[24] == 393); + try expect(v[25] == 394); + try expect(v[26] == 395); + try expect(v[27] == 396); + try expect(v[28] == 397); + try expect(v[29] == 398); + try expect(v[30] == 399); + try expect(v[31] == 400); + c_vector_32_u32(.{ + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + }, 32); + c_test_vector_32_u32(); +} + +export fn zig_ret_vector_48_u32() @Vector(48, u32) { + return .{ + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + }; +} +export fn zig_vector_48_u32(v: @Vector(48, u32), i: usize) void { + expect(v[0] == 481) catch @panic("test failure"); + expect(v[1] == 482) catch @panic("test failure"); + expect(v[2] == 483) catch @panic("test failure"); + expect(v[3] == 484) catch @panic("test failure"); + expect(v[4] == 485) catch @panic("test failure"); + expect(v[5] == 486) catch @panic("test failure"); + expect(v[6] == 487) catch @panic("test failure"); + expect(v[7] == 488) catch @panic("test failure"); + expect(v[8] == 489) catch @panic("test failure"); + expect(v[9] == 490) catch @panic("test failure"); + expect(v[10] == 491) catch @panic("test failure"); + expect(v[11] == 492) catch @panic("test failure"); + expect(v[12] == 493) catch @panic("test failure"); + expect(v[13] == 494) catch @panic("test failure"); + expect(v[14] == 495) catch @panic("test failure"); + expect(v[15] == 496) catch @panic("test failure"); + expect(v[16] == 497) catch @panic("test failure"); + expect(v[17] == 498) catch @panic("test failure"); + expect(v[18] == 499) catch @panic("test failure"); + expect(v[19] == 500) catch @panic("test failure"); + expect(v[20] == 501) catch @panic("test failure"); + expect(v[21] == 502) catch @panic("test failure"); + expect(v[22] == 503) catch @panic("test failure"); + expect(v[23] == 504) catch @panic("test failure"); + expect(v[24] == 505) catch @panic("test failure"); + expect(v[25] == 506) catch @panic("test failure"); + expect(v[26] == 507) catch @panic("test failure"); + expect(v[27] == 508) catch @panic("test failure"); + expect(v[28] == 509) catch @panic("test failure"); + expect(v[29] == 510) catch @panic("test failure"); + expect(v[30] == 511) catch @panic("test failure"); + expect(v[31] == 512) catch @panic("test failure"); + expect(v[32] == 513) catch @panic("test failure"); + expect(v[33] == 514) catch @panic("test failure"); + expect(v[34] == 515) catch @panic("test failure"); + expect(v[35] == 516) catch @panic("test failure"); + expect(v[36] == 517) catch @panic("test failure"); + expect(v[37] == 518) catch @panic("test failure"); + expect(v[38] == 519) catch @panic("test failure"); + expect(v[39] == 520) catch @panic("test failure"); + expect(v[40] == 521) catch @panic("test failure"); + expect(v[41] == 522) catch @panic("test failure"); + expect(v[42] == 523) catch @panic("test failure"); + expect(v[43] == 524) catch @panic("test failure"); + expect(v[44] == 525) catch @panic("test failure"); + expect(v[45] == 526) catch @panic("test failure"); + expect(v[46] == 527) catch @panic("test failure"); + expect(v[47] == 528) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_u32() @Vector(48, u32); +extern fn c_vector_48_u32(@Vector(48, u32), usize) void; +extern fn c_test_vector_48_u32() void; + +test "@Vector(48, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_48_u32(); + try expect(v[0] == 529); + try expect(v[1] == 530); + try expect(v[2] == 531); + try expect(v[3] == 532); + try expect(v[4] == 533); + try expect(v[5] == 534); + try expect(v[6] == 535); + try expect(v[7] == 536); + try expect(v[8] == 537); + try expect(v[9] == 538); + try expect(v[10] == 539); + try expect(v[11] == 540); + try expect(v[12] == 541); + try expect(v[13] == 542); + try expect(v[14] == 543); + try expect(v[15] == 544); + try expect(v[16] == 545); + try expect(v[17] == 546); + try expect(v[18] == 547); + try expect(v[19] == 548); + try expect(v[20] == 549); + try expect(v[21] == 550); + try expect(v[22] == 551); + try expect(v[23] == 552); + try expect(v[24] == 553); + try expect(v[25] == 554); + try expect(v[26] == 555); + try expect(v[27] == 556); + try expect(v[28] == 557); + try expect(v[29] == 558); + try expect(v[30] == 559); + try expect(v[31] == 560); + try expect(v[32] == 561); + try expect(v[33] == 562); + try expect(v[34] == 563); + try expect(v[35] == 564); + try expect(v[36] == 565); + try expect(v[37] == 566); + try expect(v[38] == 567); + try expect(v[39] == 568); + try expect(v[40] == 569); + try expect(v[41] == 570); + try expect(v[42] == 571); + try expect(v[43] == 572); + try expect(v[44] == 573); + try expect(v[45] == 574); + try expect(v[46] == 575); + try expect(v[47] == 576); + c_vector_48_u32(.{ + 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, + 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, + 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + }, 48); + c_test_vector_48_u32(); +} + +export fn zig_ret_vector_64_u32() @Vector(64, u32) { + return .{ + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, + 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, + 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, + }; +} +export fn zig_vector_64_u32(v: @Vector(64, u32), i: usize) void { + expect(v[0] == 689) catch @panic("test failure"); + expect(v[1] == 690) catch @panic("test failure"); + expect(v[2] == 691) catch @panic("test failure"); + expect(v[3] == 692) catch @panic("test failure"); + expect(v[4] == 693) catch @panic("test failure"); + expect(v[5] == 694) catch @panic("test failure"); + expect(v[6] == 695) catch @panic("test failure"); + expect(v[7] == 696) catch @panic("test failure"); + expect(v[8] == 697) catch @panic("test failure"); + expect(v[9] == 698) catch @panic("test failure"); + expect(v[10] == 699) catch @panic("test failure"); + expect(v[11] == 700) catch @panic("test failure"); + expect(v[12] == 701) catch @panic("test failure"); + expect(v[13] == 702) catch @panic("test failure"); + expect(v[14] == 703) catch @panic("test failure"); + expect(v[15] == 704) catch @panic("test failure"); + expect(v[16] == 705) catch @panic("test failure"); + expect(v[17] == 706) catch @panic("test failure"); + expect(v[18] == 707) catch @panic("test failure"); + expect(v[19] == 708) catch @panic("test failure"); + expect(v[20] == 709) catch @panic("test failure"); + expect(v[21] == 710) catch @panic("test failure"); + expect(v[22] == 711) catch @panic("test failure"); + expect(v[23] == 712) catch @panic("test failure"); + expect(v[24] == 713) catch @panic("test failure"); + expect(v[25] == 714) catch @panic("test failure"); + expect(v[26] == 715) catch @panic("test failure"); + expect(v[27] == 716) catch @panic("test failure"); + expect(v[28] == 717) catch @panic("test failure"); + expect(v[29] == 718) catch @panic("test failure"); + expect(v[30] == 719) catch @panic("test failure"); + expect(v[31] == 720) catch @panic("test failure"); + expect(v[32] == 721) catch @panic("test failure"); + expect(v[33] == 722) catch @panic("test failure"); + expect(v[34] == 723) catch @panic("test failure"); + expect(v[35] == 724) catch @panic("test failure"); + expect(v[36] == 725) catch @panic("test failure"); + expect(v[37] == 726) catch @panic("test failure"); + expect(v[38] == 727) catch @panic("test failure"); + expect(v[39] == 728) catch @panic("test failure"); + expect(v[40] == 729) catch @panic("test failure"); + expect(v[41] == 730) catch @panic("test failure"); + expect(v[42] == 731) catch @panic("test failure"); + expect(v[43] == 732) catch @panic("test failure"); + expect(v[44] == 733) catch @panic("test failure"); + expect(v[45] == 734) catch @panic("test failure"); + expect(v[46] == 735) catch @panic("test failure"); + expect(v[47] == 736) catch @panic("test failure"); + expect(v[48] == 737) catch @panic("test failure"); + expect(v[49] == 738) catch @panic("test failure"); + expect(v[50] == 739) catch @panic("test failure"); + expect(v[51] == 740) catch @panic("test failure"); + expect(v[52] == 741) catch @panic("test failure"); + expect(v[53] == 742) catch @panic("test failure"); + expect(v[54] == 743) catch @panic("test failure"); + expect(v[55] == 744) catch @panic("test failure"); + expect(v[56] == 745) catch @panic("test failure"); + expect(v[57] == 746) catch @panic("test failure"); + expect(v[58] == 747) catch @panic("test failure"); + expect(v[59] == 748) catch @panic("test failure"); + expect(v[60] == 749) catch @panic("test failure"); + expect(v[61] == 750) catch @panic("test failure"); + expect(v[62] == 751) catch @panic("test failure"); + expect(v[63] == 752) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_u32() @Vector(64, u32); +extern fn c_vector_64_u32(@Vector(64, u32), usize) void; +extern fn c_test_vector_64_u32() void; + +test "@Vector(64, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_u32(); + try expect(v[0] == 753); + try expect(v[1] == 754); + try expect(v[2] == 755); + try expect(v[3] == 756); + try expect(v[4] == 757); + try expect(v[5] == 758); + try expect(v[6] == 759); + try expect(v[7] == 760); + try expect(v[8] == 761); + try expect(v[9] == 762); + try expect(v[10] == 763); + try expect(v[11] == 764); + try expect(v[12] == 765); + try expect(v[13] == 766); + try expect(v[14] == 767); + try expect(v[15] == 768); + try expect(v[16] == 769); + try expect(v[17] == 770); + try expect(v[18] == 771); + try expect(v[19] == 772); + try expect(v[20] == 773); + try expect(v[21] == 774); + try expect(v[22] == 775); + try expect(v[23] == 776); + try expect(v[24] == 777); + try expect(v[25] == 778); + try expect(v[26] == 779); + try expect(v[27] == 780); + try expect(v[28] == 781); + try expect(v[29] == 782); + try expect(v[30] == 783); + try expect(v[31] == 784); + try expect(v[32] == 785); + try expect(v[33] == 786); + try expect(v[34] == 787); + try expect(v[35] == 788); + try expect(v[36] == 789); + try expect(v[37] == 790); + try expect(v[38] == 791); + try expect(v[39] == 792); + try expect(v[40] == 793); + try expect(v[41] == 794); + try expect(v[42] == 795); + try expect(v[43] == 796); + try expect(v[44] == 797); + try expect(v[45] == 798); + try expect(v[46] == 799); + try expect(v[47] == 800); + try expect(v[48] == 801); + try expect(v[49] == 802); + try expect(v[50] == 803); + try expect(v[51] == 804); + try expect(v[52] == 805); + try expect(v[53] == 806); + try expect(v[54] == 807); + try expect(v[55] == 808); + try expect(v[56] == 809); + try expect(v[57] == 810); + try expect(v[58] == 811); + try expect(v[59] == 812); + try expect(v[60] == 813); + try expect(v[61] == 814); + try expect(v[62] == 815); + try expect(v[63] == 816); + c_vector_64_u32(.{ + 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, + }, 64); + c_test_vector_64_u32(); +} + +export fn zig_ret_vector_96_u32() @Vector(96, u32) { + return .{ + 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, + 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, + 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, + 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, + 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, + }; +} +export fn zig_vector_96_u32(v: @Vector(96, u32), i: usize) void { + expect(v[0] == 986) catch @panic("test failure"); + expect(v[1] == 987) catch @panic("test failure"); + expect(v[2] == 988) catch @panic("test failure"); + expect(v[3] == 989) catch @panic("test failure"); + expect(v[4] == 990) catch @panic("test failure"); + expect(v[5] == 991) catch @panic("test failure"); + expect(v[6] == 992) catch @panic("test failure"); + expect(v[7] == 993) catch @panic("test failure"); + expect(v[8] == 994) catch @panic("test failure"); + expect(v[9] == 995) catch @panic("test failure"); + expect(v[10] == 996) catch @panic("test failure"); + expect(v[11] == 997) catch @panic("test failure"); + expect(v[12] == 998) catch @panic("test failure"); + expect(v[13] == 999) catch @panic("test failure"); + expect(v[14] == 1000) catch @panic("test failure"); + expect(v[15] == 1001) catch @panic("test failure"); + expect(v[16] == 1002) catch @panic("test failure"); + expect(v[17] == 1003) catch @panic("test failure"); + expect(v[18] == 1004) catch @panic("test failure"); + expect(v[19] == 1005) catch @panic("test failure"); + expect(v[20] == 1006) catch @panic("test failure"); + expect(v[21] == 1007) catch @panic("test failure"); + expect(v[22] == 1008) catch @panic("test failure"); + expect(v[23] == 1009) catch @panic("test failure"); + expect(v[24] == 1010) catch @panic("test failure"); + expect(v[25] == 1011) catch @panic("test failure"); + expect(v[26] == 1012) catch @panic("test failure"); + expect(v[27] == 1013) catch @panic("test failure"); + expect(v[28] == 1014) catch @panic("test failure"); + expect(v[29] == 1015) catch @panic("test failure"); + expect(v[30] == 1016) catch @panic("test failure"); + expect(v[31] == 1017) catch @panic("test failure"); + expect(v[32] == 1018) catch @panic("test failure"); + expect(v[33] == 1019) catch @panic("test failure"); + expect(v[34] == 1020) catch @panic("test failure"); + expect(v[35] == 1021) catch @panic("test failure"); + expect(v[36] == 1022) catch @panic("test failure"); + expect(v[37] == 1023) catch @panic("test failure"); + expect(v[38] == 1024) catch @panic("test failure"); + expect(v[39] == 1025) catch @panic("test failure"); + expect(v[40] == 1026) catch @panic("test failure"); + expect(v[41] == 1027) catch @panic("test failure"); + expect(v[42] == 1028) catch @panic("test failure"); + expect(v[43] == 1029) catch @panic("test failure"); + expect(v[44] == 1030) catch @panic("test failure"); + expect(v[45] == 1031) catch @panic("test failure"); + expect(v[46] == 1032) catch @panic("test failure"); + expect(v[47] == 1033) catch @panic("test failure"); + expect(v[48] == 1034) catch @panic("test failure"); + expect(v[49] == 1035) catch @panic("test failure"); + expect(v[50] == 1036) catch @panic("test failure"); + expect(v[51] == 1037) catch @panic("test failure"); + expect(v[52] == 1038) catch @panic("test failure"); + expect(v[53] == 1039) catch @panic("test failure"); + expect(v[54] == 1040) catch @panic("test failure"); + expect(v[55] == 1041) catch @panic("test failure"); + expect(v[56] == 1042) catch @panic("test failure"); + expect(v[57] == 1043) catch @panic("test failure"); + expect(v[58] == 1044) catch @panic("test failure"); + expect(v[59] == 1045) catch @panic("test failure"); + expect(v[60] == 1046) catch @panic("test failure"); + expect(v[61] == 1047) catch @panic("test failure"); + expect(v[62] == 1048) catch @panic("test failure"); + expect(v[63] == 1049) catch @panic("test failure"); + expect(v[64] == 1050) catch @panic("test failure"); + expect(v[65] == 1051) catch @panic("test failure"); + expect(v[66] == 1052) catch @panic("test failure"); + expect(v[67] == 1053) catch @panic("test failure"); + expect(v[68] == 1054) catch @panic("test failure"); + expect(v[69] == 1055) catch @panic("test failure"); + expect(v[70] == 1056) catch @panic("test failure"); + expect(v[71] == 1057) catch @panic("test failure"); + expect(v[72] == 1058) catch @panic("test failure"); + expect(v[73] == 1059) catch @panic("test failure"); + expect(v[74] == 1060) catch @panic("test failure"); + expect(v[75] == 1061) catch @panic("test failure"); + expect(v[76] == 1062) catch @panic("test failure"); + expect(v[77] == 1063) catch @panic("test failure"); + expect(v[78] == 1064) catch @panic("test failure"); + expect(v[79] == 1065) catch @panic("test failure"); + expect(v[80] == 1066) catch @panic("test failure"); + expect(v[81] == 1067) catch @panic("test failure"); + expect(v[82] == 1068) catch @panic("test failure"); + expect(v[83] == 1069) catch @panic("test failure"); + expect(v[84] == 1070) catch @panic("test failure"); + expect(v[85] == 1071) catch @panic("test failure"); + expect(v[86] == 1072) catch @panic("test failure"); + expect(v[87] == 1073) catch @panic("test failure"); + expect(v[88] == 1074) catch @panic("test failure"); + expect(v[89] == 1075) catch @panic("test failure"); + expect(v[90] == 1076) catch @panic("test failure"); + expect(v[91] == 1077) catch @panic("test failure"); + expect(v[92] == 1078) catch @panic("test failure"); + expect(v[93] == 1079) catch @panic("test failure"); + expect(v[94] == 1080) catch @panic("test failure"); + expect(v[95] == 1081) catch @panic("test failure"); + expect(i == 96) catch @panic("test failure"); +} + +extern fn c_ret_vector_96_u32() @Vector(96, u32); +extern fn c_vector_96_u32(@Vector(96, u32), usize) void; +extern fn c_test_vector_96_u32() void; + +test "@Vector(96, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_96_u32(); + try expect(v[0] == 1082); + try expect(v[1] == 1083); + try expect(v[2] == 1084); + try expect(v[3] == 1085); + try expect(v[4] == 1086); + try expect(v[5] == 1087); + try expect(v[6] == 1088); + try expect(v[7] == 1089); + try expect(v[8] == 1090); + try expect(v[9] == 1091); + try expect(v[10] == 1092); + try expect(v[11] == 1093); + try expect(v[12] == 1094); + try expect(v[13] == 1095); + try expect(v[14] == 1096); + try expect(v[15] == 1097); + try expect(v[16] == 1098); + try expect(v[17] == 1099); + try expect(v[18] == 1100); + try expect(v[19] == 1101); + try expect(v[20] == 1102); + try expect(v[21] == 1103); + try expect(v[22] == 1104); + try expect(v[23] == 1105); + try expect(v[24] == 1106); + try expect(v[25] == 1107); + try expect(v[26] == 1108); + try expect(v[27] == 1109); + try expect(v[28] == 1110); + try expect(v[29] == 1111); + try expect(v[30] == 1112); + try expect(v[31] == 1113); + try expect(v[32] == 1114); + try expect(v[33] == 1115); + try expect(v[34] == 1116); + try expect(v[35] == 1117); + try expect(v[36] == 1118); + try expect(v[37] == 1119); + try expect(v[38] == 1120); + try expect(v[39] == 1121); + try expect(v[40] == 1122); + try expect(v[41] == 1123); + try expect(v[42] == 1124); + try expect(v[43] == 1125); + try expect(v[44] == 1126); + try expect(v[45] == 1127); + try expect(v[46] == 1128); + try expect(v[47] == 1129); + try expect(v[48] == 1130); + try expect(v[49] == 1131); + try expect(v[50] == 1132); + try expect(v[51] == 1133); + try expect(v[52] == 1134); + try expect(v[53] == 1135); + try expect(v[54] == 1136); + try expect(v[55] == 1137); + try expect(v[56] == 1138); + try expect(v[57] == 1139); + try expect(v[58] == 1140); + try expect(v[59] == 1141); + try expect(v[60] == 1142); + try expect(v[61] == 1143); + try expect(v[62] == 1144); + try expect(v[63] == 1145); + try expect(v[64] == 1146); + try expect(v[65] == 1147); + try expect(v[66] == 1148); + try expect(v[67] == 1149); + try expect(v[68] == 1150); + try expect(v[69] == 1151); + try expect(v[70] == 1152); + try expect(v[71] == 1153); + try expect(v[72] == 1154); + try expect(v[73] == 1155); + try expect(v[74] == 1156); + try expect(v[75] == 1157); + try expect(v[76] == 1158); + try expect(v[77] == 1159); + try expect(v[78] == 1160); + try expect(v[79] == 1161); + try expect(v[80] == 1162); + try expect(v[81] == 1163); + try expect(v[82] == 1164); + try expect(v[83] == 1165); + try expect(v[84] == 1166); + try expect(v[85] == 1167); + try expect(v[86] == 1168); + try expect(v[87] == 1169); + try expect(v[88] == 1170); + try expect(v[89] == 1171); + try expect(v[90] == 1172); + try expect(v[91] == 1173); + try expect(v[92] == 1174); + try expect(v[93] == 1175); + try expect(v[94] == 1176); + try expect(v[95] == 1177); + c_vector_96_u32(.{ + 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, + 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, + 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, + 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, + 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, + 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, + }, 96); + c_test_vector_96_u32(); +} + +export fn zig_ret_vector_128_u32() @Vector(128, u32) { + return .{ + 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, + 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, + 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, + 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, + 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, + 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, + 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, + }; +} +export fn zig_vector_128_u32(v: @Vector(128, u32), i: usize) void { + expect(v[0] == 1402) catch @panic("test failure"); + expect(v[1] == 1403) catch @panic("test failure"); + expect(v[2] == 1404) catch @panic("test failure"); + expect(v[3] == 1405) catch @panic("test failure"); + expect(v[4] == 1406) catch @panic("test failure"); + expect(v[5] == 1407) catch @panic("test failure"); + expect(v[6] == 1408) catch @panic("test failure"); + expect(v[7] == 1409) catch @panic("test failure"); + expect(v[8] == 1410) catch @panic("test failure"); + expect(v[9] == 1411) catch @panic("test failure"); + expect(v[10] == 1412) catch @panic("test failure"); + expect(v[11] == 1413) catch @panic("test failure"); + expect(v[12] == 1414) catch @panic("test failure"); + expect(v[13] == 1415) catch @panic("test failure"); + expect(v[14] == 1416) catch @panic("test failure"); + expect(v[15] == 1417) catch @panic("test failure"); + expect(v[16] == 1418) catch @panic("test failure"); + expect(v[17] == 1419) catch @panic("test failure"); + expect(v[18] == 1420) catch @panic("test failure"); + expect(v[19] == 1421) catch @panic("test failure"); + expect(v[20] == 1422) catch @panic("test failure"); + expect(v[21] == 1423) catch @panic("test failure"); + expect(v[22] == 1424) catch @panic("test failure"); + expect(v[23] == 1425) catch @panic("test failure"); + expect(v[24] == 1426) catch @panic("test failure"); + expect(v[25] == 1427) catch @panic("test failure"); + expect(v[26] == 1428) catch @panic("test failure"); + expect(v[27] == 1429) catch @panic("test failure"); + expect(v[28] == 1430) catch @panic("test failure"); + expect(v[29] == 1431) catch @panic("test failure"); + expect(v[30] == 1432) catch @panic("test failure"); + expect(v[31] == 1433) catch @panic("test failure"); + expect(v[32] == 1434) catch @panic("test failure"); + expect(v[33] == 1435) catch @panic("test failure"); + expect(v[34] == 1436) catch @panic("test failure"); + expect(v[35] == 1437) catch @panic("test failure"); + expect(v[36] == 1438) catch @panic("test failure"); + expect(v[37] == 1439) catch @panic("test failure"); + expect(v[38] == 1440) catch @panic("test failure"); + expect(v[39] == 1441) catch @panic("test failure"); + expect(v[40] == 1442) catch @panic("test failure"); + expect(v[41] == 1443) catch @panic("test failure"); + expect(v[42] == 1444) catch @panic("test failure"); + expect(v[43] == 1445) catch @panic("test failure"); + expect(v[44] == 1446) catch @panic("test failure"); + expect(v[45] == 1447) catch @panic("test failure"); + expect(v[46] == 1448) catch @panic("test failure"); + expect(v[47] == 1449) catch @panic("test failure"); + expect(v[48] == 1450) catch @panic("test failure"); + expect(v[49] == 1451) catch @panic("test failure"); + expect(v[50] == 1452) catch @panic("test failure"); + expect(v[51] == 1453) catch @panic("test failure"); + expect(v[52] == 1454) catch @panic("test failure"); + expect(v[53] == 1455) catch @panic("test failure"); + expect(v[54] == 1456) catch @panic("test failure"); + expect(v[55] == 1457) catch @panic("test failure"); + expect(v[56] == 1458) catch @panic("test failure"); + expect(v[57] == 1459) catch @panic("test failure"); + expect(v[58] == 1460) catch @panic("test failure"); + expect(v[59] == 1461) catch @panic("test failure"); + expect(v[60] == 1462) catch @panic("test failure"); + expect(v[61] == 1463) catch @panic("test failure"); + expect(v[62] == 1464) catch @panic("test failure"); + expect(v[63] == 1465) catch @panic("test failure"); + expect(v[64] == 1466) catch @panic("test failure"); + expect(v[65] == 1467) catch @panic("test failure"); + expect(v[66] == 1468) catch @panic("test failure"); + expect(v[67] == 1469) catch @panic("test failure"); + expect(v[68] == 1470) catch @panic("test failure"); + expect(v[69] == 1471) catch @panic("test failure"); + expect(v[70] == 1472) catch @panic("test failure"); + expect(v[71] == 1473) catch @panic("test failure"); + expect(v[72] == 1474) catch @panic("test failure"); + expect(v[73] == 1475) catch @panic("test failure"); + expect(v[74] == 1476) catch @panic("test failure"); + expect(v[75] == 1477) catch @panic("test failure"); + expect(v[76] == 1478) catch @panic("test failure"); + expect(v[77] == 1479) catch @panic("test failure"); + expect(v[78] == 1480) catch @panic("test failure"); + expect(v[79] == 1481) catch @panic("test failure"); + expect(v[80] == 1482) catch @panic("test failure"); + expect(v[81] == 1483) catch @panic("test failure"); + expect(v[82] == 1484) catch @panic("test failure"); + expect(v[83] == 1485) catch @panic("test failure"); + expect(v[84] == 1486) catch @panic("test failure"); + expect(v[85] == 1487) catch @panic("test failure"); + expect(v[86] == 1488) catch @panic("test failure"); + expect(v[87] == 1489) catch @panic("test failure"); + expect(v[88] == 1490) catch @panic("test failure"); + expect(v[89] == 1491) catch @panic("test failure"); + expect(v[90] == 1492) catch @panic("test failure"); + expect(v[91] == 1493) catch @panic("test failure"); + expect(v[92] == 1494) catch @panic("test failure"); + expect(v[93] == 1495) catch @panic("test failure"); + expect(v[94] == 1496) catch @panic("test failure"); + expect(v[95] == 1497) catch @panic("test failure"); + expect(v[96] == 1498) catch @panic("test failure"); + expect(v[97] == 1499) catch @panic("test failure"); + expect(v[98] == 1500) catch @panic("test failure"); + expect(v[99] == 1501) catch @panic("test failure"); + expect(v[100] == 1502) catch @panic("test failure"); + expect(v[101] == 1503) catch @panic("test failure"); + expect(v[102] == 1504) catch @panic("test failure"); + expect(v[103] == 1505) catch @panic("test failure"); + expect(v[104] == 1506) catch @panic("test failure"); + expect(v[105] == 1507) catch @panic("test failure"); + expect(v[106] == 1508) catch @panic("test failure"); + expect(v[107] == 1509) catch @panic("test failure"); + expect(v[108] == 1510) catch @panic("test failure"); + expect(v[109] == 1511) catch @panic("test failure"); + expect(v[110] == 1512) catch @panic("test failure"); + expect(v[111] == 1513) catch @panic("test failure"); + expect(v[112] == 1514) catch @panic("test failure"); + expect(v[113] == 1515) catch @panic("test failure"); + expect(v[114] == 1516) catch @panic("test failure"); + expect(v[115] == 1517) catch @panic("test failure"); + expect(v[116] == 1518) catch @panic("test failure"); + expect(v[117] == 1519) catch @panic("test failure"); + expect(v[118] == 1520) catch @panic("test failure"); + expect(v[119] == 1521) catch @panic("test failure"); + expect(v[120] == 1522) catch @panic("test failure"); + expect(v[121] == 1523) catch @panic("test failure"); + expect(v[122] == 1524) catch @panic("test failure"); + expect(v[123] == 1525) catch @panic("test failure"); + expect(v[124] == 1526) catch @panic("test failure"); + expect(v[125] == 1527) catch @panic("test failure"); + expect(v[126] == 1528) catch @panic("test failure"); + expect(v[127] == 1529) catch @panic("test failure"); + expect(i == 128) catch @panic("test failure"); +} + +extern fn c_ret_vector_128_u32() @Vector(128, u32); +extern fn c_vector_128_u32(@Vector(128, u32), usize) void; +extern fn c_test_vector_128_u32() void; + +test "@Vector(128, u32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_128_u32(); + try expect(v[0] == 1530); + try expect(v[1] == 1531); + try expect(v[2] == 1532); + try expect(v[3] == 1533); + try expect(v[4] == 1534); + try expect(v[5] == 1535); + try expect(v[6] == 1536); + try expect(v[7] == 1537); + try expect(v[8] == 1538); + try expect(v[9] == 1539); + try expect(v[10] == 1540); + try expect(v[11] == 1541); + try expect(v[12] == 1542); + try expect(v[13] == 1543); + try expect(v[14] == 1544); + try expect(v[15] == 1545); + try expect(v[16] == 1546); + try expect(v[17] == 1547); + try expect(v[18] == 1548); + try expect(v[19] == 1549); + try expect(v[20] == 1550); + try expect(v[21] == 1551); + try expect(v[22] == 1552); + try expect(v[23] == 1553); + try expect(v[24] == 1554); + try expect(v[25] == 1555); + try expect(v[26] == 1556); + try expect(v[27] == 1557); + try expect(v[28] == 1558); + try expect(v[29] == 1559); + try expect(v[30] == 1560); + try expect(v[31] == 1561); + try expect(v[32] == 1562); + try expect(v[33] == 1563); + try expect(v[34] == 1564); + try expect(v[35] == 1565); + try expect(v[36] == 1566); + try expect(v[37] == 1567); + try expect(v[38] == 1568); + try expect(v[39] == 1569); + try expect(v[40] == 1570); + try expect(v[41] == 1571); + try expect(v[42] == 1572); + try expect(v[43] == 1573); + try expect(v[44] == 1574); + try expect(v[45] == 1575); + try expect(v[46] == 1576); + try expect(v[47] == 1577); + try expect(v[48] == 1578); + try expect(v[49] == 1579); + try expect(v[50] == 1580); + try expect(v[51] == 1581); + try expect(v[52] == 1582); + try expect(v[53] == 1583); + try expect(v[54] == 1584); + try expect(v[55] == 1585); + try expect(v[56] == 1586); + try expect(v[57] == 1587); + try expect(v[58] == 1588); + try expect(v[59] == 1589); + try expect(v[60] == 1590); + try expect(v[61] == 1591); + try expect(v[62] == 1592); + try expect(v[63] == 1593); + try expect(v[64] == 1594); + try expect(v[65] == 1595); + try expect(v[66] == 1596); + try expect(v[67] == 1597); + try expect(v[68] == 1598); + try expect(v[69] == 1599); + try expect(v[70] == 1600); + try expect(v[71] == 1601); + try expect(v[72] == 1602); + try expect(v[73] == 1603); + try expect(v[74] == 1604); + try expect(v[75] == 1605); + try expect(v[76] == 1606); + try expect(v[77] == 1607); + try expect(v[78] == 1608); + try expect(v[79] == 1609); + try expect(v[80] == 1610); + try expect(v[81] == 1611); + try expect(v[82] == 1612); + try expect(v[83] == 1613); + try expect(v[84] == 1614); + try expect(v[85] == 1615); + try expect(v[86] == 1616); + try expect(v[87] == 1617); + try expect(v[88] == 1618); + try expect(v[89] == 1619); + try expect(v[90] == 1620); + try expect(v[91] == 1621); + try expect(v[92] == 1622); + try expect(v[93] == 1623); + try expect(v[94] == 1624); + try expect(v[95] == 1625); + try expect(v[96] == 1626); + try expect(v[97] == 1627); + try expect(v[98] == 1628); + try expect(v[99] == 1629); + try expect(v[100] == 1630); + try expect(v[101] == 1631); + try expect(v[102] == 1632); + try expect(v[103] == 1633); + try expect(v[104] == 1634); + try expect(v[105] == 1635); + try expect(v[106] == 1636); + try expect(v[107] == 1637); + try expect(v[108] == 1638); + try expect(v[109] == 1639); + try expect(v[110] == 1640); + try expect(v[111] == 1641); + try expect(v[112] == 1642); + try expect(v[113] == 1643); + try expect(v[114] == 1644); + try expect(v[115] == 1645); + try expect(v[116] == 1646); + try expect(v[117] == 1647); + try expect(v[118] == 1648); + try expect(v[119] == 1649); + try expect(v[120] == 1650); + try expect(v[121] == 1651); + try expect(v[122] == 1652); + try expect(v[123] == 1653); + try expect(v[124] == 1654); + try expect(v[125] == 1655); + try expect(v[126] == 1656); + try expect(v[127] == 1657); + c_vector_128_u32(.{ + 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, + 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, + 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, + 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, + 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, + 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, + 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, + 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, + }, 128); + c_test_vector_128_u32(); +} + +export fn zig_ret_vector_1_u64() @Vector(1, u64) { + return .{1}; +} +export fn zig_vector_1_u64(v: @Vector(1, u64), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_u64() @Vector(1, u64); +extern fn c_vector_1_u64(@Vector(1, u64), usize) void; +extern fn c_test_vector_1_u64() void; + +test "@Vector(1, u64)" { + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest; + + const v = c_ret_vector_1_u64(); + try expect(v[0] == 3); + c_vector_1_u64(.{4}, 1); + c_test_vector_1_u64(); +} + +export fn zig_ret_vector_2_u64() @Vector(2, u64) { + return .{ 5, 6 }; +} +export fn zig_vector_2_u64(v: @Vector(2, u64), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_u64() @Vector(2, u64); +extern fn c_vector_2_u64(@Vector(2, u64), usize) void; +extern fn c_test_vector_2_u64() void; + +test "@Vector(2, u64)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_2_u64(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_u64(.{ 11, 12 }, 2); + c_test_vector_2_u64(); +} + +export fn zig_ret_vector_3_u64() @Vector(3, u64) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_u64(v: @Vector(3, u64), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_u64() @Vector(3, u64); +extern fn c_vector_3_u64(@Vector(3, u64), usize) void; +extern fn c_test_vector_3_u64() void; + +test "@Vector(3, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_3_u64(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_u64(.{ 22, 23, 24 }, 3); + c_test_vector_3_u64(); +} + +export fn zig_ret_vector_4_u64() @Vector(4, u64) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_u64(v: @Vector(4, u64), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} + +extern fn c_ret_vector_4_u64() @Vector(4, u64); +extern fn c_vector_4_u64(@Vector(4, u64), usize) void; +extern fn c_test_vector_4_u64() void; + +test "@Vector(4, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_4_u64(); + try expect(v[0] == 33); + try expect(v[1] == 34); + try expect(v[2] == 35); + try expect(v[3] == 36); + c_vector_4_u64(.{ 37, 38, 39, 40 }, 4); + c_test_vector_4_u64(); +} + +export fn zig_ret_vector_6_u64() @Vector(6, u64) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_u64(v: @Vector(6, u64), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_u64() @Vector(6, u64); +extern fn c_vector_6_u64(@Vector(6, u64), usize) void; +extern fn c_test_vector_6_u64() void; + +test "@Vector(6, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + + const v = c_ret_vector_6_u64(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_u64(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_u64(); +} + +export fn zig_ret_vector_8_u64() @Vector(8, u64) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_u64(v: @Vector(8, u64), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_u64() @Vector(8, u64); +extern fn c_vector_8_u64(@Vector(8, u64), usize) void; +extern fn c_test_vector_8_u64() void; + +test "@Vector(8, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_8_u64(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_u64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_u64(); +} + +export fn zig_ret_vector_12_u64() @Vector(12, u64) { + return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 }; +} +export fn zig_vector_12_u64(v: @Vector(12, u64), i: usize) void { + expect(v[0] == 109) catch @panic("test failure"); + expect(v[1] == 110) catch @panic("test failure"); + expect(v[2] == 111) catch @panic("test failure"); + expect(v[3] == 112) catch @panic("test failure"); + expect(v[4] == 113) catch @panic("test failure"); + expect(v[5] == 114) catch @panic("test failure"); + expect(v[6] == 115) catch @panic("test failure"); + expect(v[7] == 116) catch @panic("test failure"); + expect(v[8] == 117) catch @panic("test failure"); + expect(v[9] == 118) catch @panic("test failure"); + expect(v[10] == 119) catch @panic("test failure"); + expect(v[11] == 120) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_u64() @Vector(12, u64); +extern fn c_vector_12_u64(@Vector(12, u64), usize) void; +extern fn c_test_vector_12_u64() void; + +test "@Vector(12, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + + const v = c_ret_vector_12_u64(); + try expect(v[0] == 121); + try expect(v[1] == 122); + try expect(v[2] == 123); + try expect(v[3] == 124); + try expect(v[4] == 125); + try expect(v[5] == 126); + try expect(v[6] == 127); + try expect(v[7] == 128); + try expect(v[8] == 129); + try expect(v[9] == 130); + try expect(v[10] == 131); + try expect(v[11] == 132); + c_vector_12_u64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12); + c_test_vector_12_u64(); +} + +export fn zig_ret_vector_16_u64() @Vector(16, u64) { + return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 }; +} +export fn zig_vector_16_u64(v: @Vector(16, u64), i: usize) void { + expect(v[0] == 161) catch @panic("test failure"); + expect(v[1] == 162) catch @panic("test failure"); + expect(v[2] == 163) catch @panic("test failure"); + expect(v[3] == 164) catch @panic("test failure"); + expect(v[4] == 165) catch @panic("test failure"); + expect(v[5] == 166) catch @panic("test failure"); + expect(v[6] == 167) catch @panic("test failure"); + expect(v[7] == 168) catch @panic("test failure"); + expect(v[8] == 169) catch @panic("test failure"); + expect(v[9] == 170) catch @panic("test failure"); + expect(v[10] == 171) catch @panic("test failure"); + expect(v[11] == 172) catch @panic("test failure"); + expect(v[12] == 173) catch @panic("test failure"); + expect(v[13] == 174) catch @panic("test failure"); + expect(v[14] == 175) catch @panic("test failure"); + expect(v[15] == 176) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_u64() @Vector(16, u64); +extern fn c_vector_16_u64(@Vector(16, u64), usize) void; +extern fn c_test_vector_16_u64() void; + +test "@Vector(16, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_16_u64(); + try expect(v[0] == 177); + try expect(v[1] == 178); + try expect(v[2] == 179); + try expect(v[3] == 180); + try expect(v[4] == 181); + try expect(v[5] == 182); + try expect(v[6] == 183); + try expect(v[7] == 184); + try expect(v[8] == 185); + try expect(v[9] == 186); + try expect(v[10] == 187); + try expect(v[11] == 188); + try expect(v[12] == 189); + try expect(v[13] == 190); + try expect(v[14] == 191); + try expect(v[15] == 192); + c_vector_16_u64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16); + c_test_vector_16_u64(); +} + +export fn zig_ret_vector_24_u64() @Vector(24, u64) { + return .{ + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, + }; +} +export fn zig_vector_24_u64(v: @Vector(24, u64), i: usize) void { + expect(v[0] == 233) catch @panic("test failure"); + expect(v[1] == 234) catch @panic("test failure"); + expect(v[2] == 235) catch @panic("test failure"); + expect(v[3] == 236) catch @panic("test failure"); + expect(v[4] == 237) catch @panic("test failure"); + expect(v[5] == 238) catch @panic("test failure"); + expect(v[6] == 239) catch @panic("test failure"); + expect(v[7] == 240) catch @panic("test failure"); + expect(v[8] == 241) catch @panic("test failure"); + expect(v[9] == 242) catch @panic("test failure"); + expect(v[10] == 243) catch @panic("test failure"); + expect(v[11] == 244) catch @panic("test failure"); + expect(v[12] == 245) catch @panic("test failure"); + expect(v[13] == 246) catch @panic("test failure"); + expect(v[14] == 247) catch @panic("test failure"); + expect(v[15] == 248) catch @panic("test failure"); + expect(v[16] == 249) catch @panic("test failure"); + expect(v[17] == 250) catch @panic("test failure"); + expect(v[18] == 251) catch @panic("test failure"); + expect(v[19] == 252) catch @panic("test failure"); + expect(v[20] == 253) catch @panic("test failure"); + expect(v[21] == 254) catch @panic("test failure"); + expect(v[22] == 255) catch @panic("test failure"); + expect(v[23] == 256) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_u64() @Vector(24, u64); +extern fn c_vector_24_u64(@Vector(24, u64), usize) void; +extern fn c_test_vector_24_u64() void; + +test "@Vector(24, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + + const v = c_ret_vector_24_u64(); + try expect(v[0] == 257); + try expect(v[1] == 258); + try expect(v[2] == 259); + try expect(v[3] == 260); + try expect(v[4] == 261); + try expect(v[5] == 262); + try expect(v[6] == 263); + try expect(v[7] == 264); + try expect(v[8] == 265); + try expect(v[9] == 266); + try expect(v[10] == 267); + try expect(v[11] == 268); + try expect(v[12] == 269); + try expect(v[13] == 270); + try expect(v[14] == 271); + try expect(v[15] == 272); + try expect(v[16] == 273); + try expect(v[17] == 274); + try expect(v[18] == 275); + try expect(v[19] == 276); + try expect(v[20] == 277); + try expect(v[21] == 278); + try expect(v[22] == 279); + try expect(v[23] == 280); + c_vector_24_u64(.{ + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, + }, 24); + c_test_vector_24_u64(); +} + +export fn zig_ret_vector_32_u64() @Vector(32, u64) { + return .{ + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + }; +} +export fn zig_vector_32_u64(v: @Vector(32, u64), i: usize) void { + expect(v[0] == 337) catch @panic("test failure"); + expect(v[1] == 338) catch @panic("test failure"); + expect(v[2] == 339) catch @panic("test failure"); + expect(v[3] == 340) catch @panic("test failure"); + expect(v[4] == 341) catch @panic("test failure"); + expect(v[5] == 342) catch @panic("test failure"); + expect(v[6] == 343) catch @panic("test failure"); + expect(v[7] == 344) catch @panic("test failure"); + expect(v[8] == 345) catch @panic("test failure"); + expect(v[9] == 346) catch @panic("test failure"); + expect(v[10] == 347) catch @panic("test failure"); + expect(v[11] == 348) catch @panic("test failure"); + expect(v[12] == 349) catch @panic("test failure"); + expect(v[13] == 350) catch @panic("test failure"); + expect(v[14] == 351) catch @panic("test failure"); + expect(v[15] == 352) catch @panic("test failure"); + expect(v[16] == 353) catch @panic("test failure"); + expect(v[17] == 354) catch @panic("test failure"); + expect(v[18] == 355) catch @panic("test failure"); + expect(v[19] == 356) catch @panic("test failure"); + expect(v[20] == 357) catch @panic("test failure"); + expect(v[21] == 358) catch @panic("test failure"); + expect(v[22] == 359) catch @panic("test failure"); + expect(v[23] == 360) catch @panic("test failure"); + expect(v[24] == 361) catch @panic("test failure"); + expect(v[25] == 362) catch @panic("test failure"); + expect(v[26] == 363) catch @panic("test failure"); + expect(v[27] == 364) catch @panic("test failure"); + expect(v[28] == 365) catch @panic("test failure"); + expect(v[29] == 366) catch @panic("test failure"); + expect(v[30] == 367) catch @panic("test failure"); + expect(v[31] == 368) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_u64() @Vector(32, u64); +extern fn c_vector_32_u64(@Vector(32, u64), usize) void; +extern fn c_test_vector_32_u64() void; + +test "@Vector(32, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_u64(); + try expect(v[0] == 369); + try expect(v[1] == 370); + try expect(v[2] == 371); + try expect(v[3] == 372); + try expect(v[4] == 373); + try expect(v[5] == 374); + try expect(v[6] == 375); + try expect(v[7] == 376); + try expect(v[8] == 377); + try expect(v[9] == 378); + try expect(v[10] == 379); + try expect(v[11] == 380); + try expect(v[12] == 381); + try expect(v[13] == 382); + try expect(v[14] == 383); + try expect(v[15] == 384); + try expect(v[16] == 385); + try expect(v[17] == 386); + try expect(v[18] == 387); + try expect(v[19] == 388); + try expect(v[20] == 389); + try expect(v[21] == 390); + try expect(v[22] == 391); + try expect(v[23] == 392); + try expect(v[24] == 393); + try expect(v[25] == 394); + try expect(v[26] == 395); + try expect(v[27] == 396); + try expect(v[28] == 397); + try expect(v[29] == 398); + try expect(v[30] == 399); + try expect(v[31] == 400); + c_vector_32_u64(.{ + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + }, 32); + c_test_vector_32_u64(); +} + +export fn zig_ret_vector_48_u64() @Vector(48, u64) { + return .{ + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + }; +} +export fn zig_vector_48_u64(v: @Vector(48, u64), i: usize) void { + expect(v[0] == 481) catch @panic("test failure"); + expect(v[1] == 482) catch @panic("test failure"); + expect(v[2] == 483) catch @panic("test failure"); + expect(v[3] == 484) catch @panic("test failure"); + expect(v[4] == 485) catch @panic("test failure"); + expect(v[5] == 486) catch @panic("test failure"); + expect(v[6] == 487) catch @panic("test failure"); + expect(v[7] == 488) catch @panic("test failure"); + expect(v[8] == 489) catch @panic("test failure"); + expect(v[9] == 490) catch @panic("test failure"); + expect(v[10] == 491) catch @panic("test failure"); + expect(v[11] == 492) catch @panic("test failure"); + expect(v[12] == 493) catch @panic("test failure"); + expect(v[13] == 494) catch @panic("test failure"); + expect(v[14] == 495) catch @panic("test failure"); + expect(v[15] == 496) catch @panic("test failure"); + expect(v[16] == 497) catch @panic("test failure"); + expect(v[17] == 498) catch @panic("test failure"); + expect(v[18] == 499) catch @panic("test failure"); + expect(v[19] == 500) catch @panic("test failure"); + expect(v[20] == 501) catch @panic("test failure"); + expect(v[21] == 502) catch @panic("test failure"); + expect(v[22] == 503) catch @panic("test failure"); + expect(v[23] == 504) catch @panic("test failure"); + expect(v[24] == 505) catch @panic("test failure"); + expect(v[25] == 506) catch @panic("test failure"); + expect(v[26] == 507) catch @panic("test failure"); + expect(v[27] == 508) catch @panic("test failure"); + expect(v[28] == 509) catch @panic("test failure"); + expect(v[29] == 510) catch @panic("test failure"); + expect(v[30] == 511) catch @panic("test failure"); + expect(v[31] == 512) catch @panic("test failure"); + expect(v[32] == 513) catch @panic("test failure"); + expect(v[33] == 514) catch @panic("test failure"); + expect(v[34] == 515) catch @panic("test failure"); + expect(v[35] == 516) catch @panic("test failure"); + expect(v[36] == 517) catch @panic("test failure"); + expect(v[37] == 518) catch @panic("test failure"); + expect(v[38] == 519) catch @panic("test failure"); + expect(v[39] == 520) catch @panic("test failure"); + expect(v[40] == 521) catch @panic("test failure"); + expect(v[41] == 522) catch @panic("test failure"); + expect(v[42] == 523) catch @panic("test failure"); + expect(v[43] == 524) catch @panic("test failure"); + expect(v[44] == 525) catch @panic("test failure"); + expect(v[45] == 526) catch @panic("test failure"); + expect(v[46] == 527) catch @panic("test failure"); + expect(v[47] == 528) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_u64() @Vector(48, u64); +extern fn c_vector_48_u64(@Vector(48, u64), usize) void; +extern fn c_test_vector_48_u64() void; + +test "@Vector(48, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + + const v = c_ret_vector_48_u64(); + try expect(v[0] == 529); + try expect(v[1] == 530); + try expect(v[2] == 531); + try expect(v[3] == 532); + try expect(v[4] == 533); + try expect(v[5] == 534); + try expect(v[6] == 535); + try expect(v[7] == 536); + try expect(v[8] == 537); + try expect(v[9] == 538); + try expect(v[10] == 539); + try expect(v[11] == 540); + try expect(v[12] == 541); + try expect(v[13] == 542); + try expect(v[14] == 543); + try expect(v[15] == 544); + try expect(v[16] == 545); + try expect(v[17] == 546); + try expect(v[18] == 547); + try expect(v[19] == 548); + try expect(v[20] == 549); + try expect(v[21] == 550); + try expect(v[22] == 551); + try expect(v[23] == 552); + try expect(v[24] == 553); + try expect(v[25] == 554); + try expect(v[26] == 555); + try expect(v[27] == 556); + try expect(v[28] == 557); + try expect(v[29] == 558); + try expect(v[30] == 559); + try expect(v[31] == 560); + try expect(v[32] == 561); + try expect(v[33] == 562); + try expect(v[34] == 563); + try expect(v[35] == 564); + try expect(v[36] == 565); + try expect(v[37] == 566); + try expect(v[38] == 567); + try expect(v[39] == 568); + try expect(v[40] == 569); + try expect(v[41] == 570); + try expect(v[42] == 571); + try expect(v[43] == 572); + try expect(v[44] == 573); + try expect(v[45] == 574); + try expect(v[46] == 575); + try expect(v[47] == 576); + c_vector_48_u64(.{ + 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, + 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, + 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + }, 48); + c_test_vector_48_u64(); +} + +export fn zig_ret_vector_64_u64() @Vector(64, u64) { + return .{ + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, + 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, + 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, + }; +} +export fn zig_vector_64_u64(v: @Vector(64, u64), i: usize) void { + expect(v[0] == 689) catch @panic("test failure"); + expect(v[1] == 690) catch @panic("test failure"); + expect(v[2] == 691) catch @panic("test failure"); + expect(v[3] == 692) catch @panic("test failure"); + expect(v[4] == 693) catch @panic("test failure"); + expect(v[5] == 694) catch @panic("test failure"); + expect(v[6] == 695) catch @panic("test failure"); + expect(v[7] == 696) catch @panic("test failure"); + expect(v[8] == 697) catch @panic("test failure"); + expect(v[9] == 698) catch @panic("test failure"); + expect(v[10] == 699) catch @panic("test failure"); + expect(v[11] == 700) catch @panic("test failure"); + expect(v[12] == 701) catch @panic("test failure"); + expect(v[13] == 702) catch @panic("test failure"); + expect(v[14] == 703) catch @panic("test failure"); + expect(v[15] == 704) catch @panic("test failure"); + expect(v[16] == 705) catch @panic("test failure"); + expect(v[17] == 706) catch @panic("test failure"); + expect(v[18] == 707) catch @panic("test failure"); + expect(v[19] == 708) catch @panic("test failure"); + expect(v[20] == 709) catch @panic("test failure"); + expect(v[21] == 710) catch @panic("test failure"); + expect(v[22] == 711) catch @panic("test failure"); + expect(v[23] == 712) catch @panic("test failure"); + expect(v[24] == 713) catch @panic("test failure"); + expect(v[25] == 714) catch @panic("test failure"); + expect(v[26] == 715) catch @panic("test failure"); + expect(v[27] == 716) catch @panic("test failure"); + expect(v[28] == 717) catch @panic("test failure"); + expect(v[29] == 718) catch @panic("test failure"); + expect(v[30] == 719) catch @panic("test failure"); + expect(v[31] == 720) catch @panic("test failure"); + expect(v[32] == 721) catch @panic("test failure"); + expect(v[33] == 722) catch @panic("test failure"); + expect(v[34] == 723) catch @panic("test failure"); + expect(v[35] == 724) catch @panic("test failure"); + expect(v[36] == 725) catch @panic("test failure"); + expect(v[37] == 726) catch @panic("test failure"); + expect(v[38] == 727) catch @panic("test failure"); + expect(v[39] == 728) catch @panic("test failure"); + expect(v[40] == 729) catch @panic("test failure"); + expect(v[41] == 730) catch @panic("test failure"); + expect(v[42] == 731) catch @panic("test failure"); + expect(v[43] == 732) catch @panic("test failure"); + expect(v[44] == 733) catch @panic("test failure"); + expect(v[45] == 734) catch @panic("test failure"); + expect(v[46] == 735) catch @panic("test failure"); + expect(v[47] == 736) catch @panic("test failure"); + expect(v[48] == 737) catch @panic("test failure"); + expect(v[49] == 738) catch @panic("test failure"); + expect(v[50] == 739) catch @panic("test failure"); + expect(v[51] == 740) catch @panic("test failure"); + expect(v[52] == 741) catch @panic("test failure"); + expect(v[53] == 742) catch @panic("test failure"); + expect(v[54] == 743) catch @panic("test failure"); + expect(v[55] == 744) catch @panic("test failure"); + expect(v[56] == 745) catch @panic("test failure"); + expect(v[57] == 746) catch @panic("test failure"); + expect(v[58] == 747) catch @panic("test failure"); + expect(v[59] == 748) catch @panic("test failure"); + expect(v[60] == 749) catch @panic("test failure"); + expect(v[61] == 750) catch @panic("test failure"); + expect(v[62] == 751) catch @panic("test failure"); + expect(v[63] == 752) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_u64() @Vector(64, u64); +extern fn c_vector_64_u64(@Vector(64, u64), usize) void; +extern fn c_test_vector_64_u64() void; + +test "@Vector(64, u64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_u64(); + try expect(v[0] == 753); + try expect(v[1] == 754); + try expect(v[2] == 755); + try expect(v[3] == 756); + try expect(v[4] == 757); + try expect(v[5] == 758); + try expect(v[6] == 759); + try expect(v[7] == 760); + try expect(v[8] == 761); + try expect(v[9] == 762); + try expect(v[10] == 763); + try expect(v[11] == 764); + try expect(v[12] == 765); + try expect(v[13] == 766); + try expect(v[14] == 767); + try expect(v[15] == 768); + try expect(v[16] == 769); + try expect(v[17] == 770); + try expect(v[18] == 771); + try expect(v[19] == 772); + try expect(v[20] == 773); + try expect(v[21] == 774); + try expect(v[22] == 775); + try expect(v[23] == 776); + try expect(v[24] == 777); + try expect(v[25] == 778); + try expect(v[26] == 779); + try expect(v[27] == 780); + try expect(v[28] == 781); + try expect(v[29] == 782); + try expect(v[30] == 783); + try expect(v[31] == 784); + try expect(v[32] == 785); + try expect(v[33] == 786); + try expect(v[34] == 787); + try expect(v[35] == 788); + try expect(v[36] == 789); + try expect(v[37] == 790); + try expect(v[38] == 791); + try expect(v[39] == 792); + try expect(v[40] == 793); + try expect(v[41] == 794); + try expect(v[42] == 795); + try expect(v[43] == 796); + try expect(v[44] == 797); + try expect(v[45] == 798); + try expect(v[46] == 799); + try expect(v[47] == 800); + try expect(v[48] == 801); + try expect(v[49] == 802); + try expect(v[50] == 803); + try expect(v[51] == 804); + try expect(v[52] == 805); + try expect(v[53] == 806); + try expect(v[54] == 807); + try expect(v[55] == 808); + try expect(v[56] == 809); + try expect(v[57] == 810); + try expect(v[58] == 811); + try expect(v[59] == 812); + try expect(v[60] == 813); + try expect(v[61] == 814); + try expect(v[62] == 815); + try expect(v[63] == 816); + c_vector_64_u64(.{ + 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, + }, 64); + c_test_vector_64_u64(); +} + +export fn zig_ret_vector_1_f32() @Vector(1, f32) { + return .{1}; +} +export fn zig_vector_1_f32(v: @Vector(1, f32), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_f32() @Vector(1, f32); +extern fn c_vector_1_f32(@Vector(1, f32), usize) void; +extern fn c_test_vector_1_f32() void; + +test "@Vector(1, f32)" { + if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest; + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest; + + const v = c_ret_vector_1_f32(); + try expect(v[0] == 3); + c_vector_1_f32(.{4}, 1); + c_test_vector_1_f32(); +} + +export fn zig_ret_vector_2_f32() @Vector(2, f32) { + return .{ 5, 6 }; +} +export fn zig_vector_2_f32(v: @Vector(2, f32), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_f32() @Vector(2, f32); +extern fn c_vector_2_f32(@Vector(2, f32), usize) void; +extern fn c_test_vector_2_f32() void; + +test "@Vector(2, f32)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; + + const v = c_ret_vector_2_f32(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_f32(.{ 11, 12 }, 2); + c_test_vector_2_f32(); +} + +export fn zig_ret_vector_3_f32() @Vector(3, f32) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_f32(v: @Vector(3, f32), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_f32() @Vector(3, f32); +extern fn c_vector_3_f32(@Vector(3, f32), usize) void; +extern fn c_test_vector_3_f32() void; + +test "@Vector(3, f32)" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + + const v = c_ret_vector_3_f32(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_f32(.{ 22, 23, 24 }, 32); + c_test_vector_3_f32(); +} + +export fn zig_ret_vector_4_f32() @Vector(4, f32) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_f32(v: @Vector(4, f32), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} +export fn zig_vector_4_f32_vector_4_f32(v0: @Vector(4, f32), v1: @Vector(4, f32), i: usize) void { + expect(v0[0] == 33) catch @panic("test failure"); + expect(v0[1] == 34) catch @panic("test failure"); + expect(v0[2] == 35) catch @panic("test failure"); + expect(v0[3] == 36) catch @panic("test failure"); + expect(v1[0] == 37) catch @panic("test failure"); + expect(v1[1] == 38) catch @panic("test failure"); + expect(v1[2] == 39) catch @panic("test failure"); + expect(v1[3] == 40) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} +extern fn c_ret_vector_4_f32() @Vector(4, f32); + +extern fn c_vector_4_f32(@Vector(4, f32), usize) void; +extern fn c_vector_4_f32_vector_4_f32(@Vector(4, f32), @Vector(4, f32), usize) void; +extern fn c_test_vector_4_f32() void; + +test "@Vector(4, f32)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_4_f32(); + try expect(v[0] == 41); + try expect(v[1] == 42); + try expect(v[2] == 43); + try expect(v[3] == 44); + c_vector_4_f32(.{ 45, 46, 47, 48 }, 4); + c_vector_4_f32_vector_4_f32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8); + c_test_vector_4_f32(); +} + +export fn zig_ret_vector_6_f32() @Vector(6, f32) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_f32(v: @Vector(6, f32), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_f32() @Vector(6, f32); +extern fn c_vector_6_f32(@Vector(6, f32), usize) void; +extern fn c_test_vector_6_f32() void; + +test "@Vector(6, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_6_f32(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_f32(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_f32(); +} + +export fn zig_ret_vector_8_f32() @Vector(8, f32) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_f32(v: @Vector(8, f32), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_f32() @Vector(8, f32); +extern fn c_vector_8_f32(@Vector(8, f32), usize) void; +extern fn c_test_vector_8_f32() void; + +test "@Vector(8, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_8_f32(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_f32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_f32(); +} + +export fn zig_ret_vector_12_f32() @Vector(12, f32) { + return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 }; +} +export fn zig_vector_12_f32(v: @Vector(12, f32), i: usize) void { + expect(v[0] == 109) catch @panic("test failure"); + expect(v[1] == 110) catch @panic("test failure"); + expect(v[2] == 111) catch @panic("test failure"); + expect(v[3] == 112) catch @panic("test failure"); + expect(v[4] == 113) catch @panic("test failure"); + expect(v[5] == 114) catch @panic("test failure"); + expect(v[6] == 115) catch @panic("test failure"); + expect(v[7] == 116) catch @panic("test failure"); + expect(v[8] == 117) catch @panic("test failure"); + expect(v[9] == 118) catch @panic("test failure"); + expect(v[10] == 119) catch @panic("test failure"); + expect(v[11] == 120) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_f32() @Vector(12, f32); +extern fn c_vector_12_f32(@Vector(12, f32), usize) void; +extern fn c_test_vector_12_f32() void; + +test "@Vector(12, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_12_f32(); + try expect(v[0] == 121); + try expect(v[1] == 122); + try expect(v[2] == 123); + try expect(v[3] == 124); + try expect(v[4] == 125); + try expect(v[5] == 126); + try expect(v[6] == 127); + try expect(v[7] == 128); + try expect(v[8] == 129); + try expect(v[9] == 130); + try expect(v[10] == 131); + try expect(v[11] == 132); + c_vector_12_f32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12); + c_test_vector_12_f32(); +} + +export fn zig_ret_vector_16_f32() @Vector(16, f32) { + return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 }; +} +export fn zig_vector_16_f32(v: @Vector(16, f32), i: usize) void { + expect(v[0] == 161) catch @panic("test failure"); + expect(v[1] == 162) catch @panic("test failure"); + expect(v[2] == 163) catch @panic("test failure"); + expect(v[3] == 164) catch @panic("test failure"); + expect(v[4] == 165) catch @panic("test failure"); + expect(v[5] == 166) catch @panic("test failure"); + expect(v[6] == 167) catch @panic("test failure"); + expect(v[7] == 168) catch @panic("test failure"); + expect(v[8] == 169) catch @panic("test failure"); + expect(v[9] == 170) catch @panic("test failure"); + expect(v[10] == 171) catch @panic("test failure"); + expect(v[11] == 172) catch @panic("test failure"); + expect(v[12] == 173) catch @panic("test failure"); + expect(v[13] == 174) catch @panic("test failure"); + expect(v[14] == 175) catch @panic("test failure"); + expect(v[15] == 176) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_f32() @Vector(16, f32); +extern fn c_vector_16_f32(@Vector(16, f32), usize) void; +extern fn c_test_vector_16_f32() void; + +test "@Vector(16, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_16_f32(); + try expect(v[0] == 177); + try expect(v[1] == 178); + try expect(v[2] == 179); + try expect(v[3] == 180); + try expect(v[4] == 181); + try expect(v[5] == 182); + try expect(v[6] == 183); + try expect(v[7] == 184); + try expect(v[8] == 185); + try expect(v[9] == 186); + try expect(v[10] == 187); + try expect(v[11] == 188); + try expect(v[12] == 189); + try expect(v[13] == 190); + try expect(v[14] == 191); + try expect(v[15] == 192); + c_vector_16_f32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16); + c_test_vector_16_f32(); +} + +export fn zig_ret_vector_24_f32() @Vector(24, f32) { + return .{ + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, + }; +} +export fn zig_vector_24_f32(v: @Vector(24, f32), i: usize) void { + expect(v[0] == 233) catch @panic("test failure"); + expect(v[1] == 234) catch @panic("test failure"); + expect(v[2] == 235) catch @panic("test failure"); + expect(v[3] == 236) catch @panic("test failure"); + expect(v[4] == 237) catch @panic("test failure"); + expect(v[5] == 238) catch @panic("test failure"); + expect(v[6] == 239) catch @panic("test failure"); + expect(v[7] == 240) catch @panic("test failure"); + expect(v[8] == 241) catch @panic("test failure"); + expect(v[9] == 242) catch @panic("test failure"); + expect(v[10] == 243) catch @panic("test failure"); + expect(v[11] == 244) catch @panic("test failure"); + expect(v[12] == 245) catch @panic("test failure"); + expect(v[13] == 246) catch @panic("test failure"); + expect(v[14] == 247) catch @panic("test failure"); + expect(v[15] == 248) catch @panic("test failure"); + expect(v[16] == 249) catch @panic("test failure"); + expect(v[17] == 250) catch @panic("test failure"); + expect(v[18] == 251) catch @panic("test failure"); + expect(v[19] == 252) catch @panic("test failure"); + expect(v[20] == 253) catch @panic("test failure"); + expect(v[21] == 254) catch @panic("test failure"); + expect(v[22] == 255) catch @panic("test failure"); + expect(v[23] == 256) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_f32() @Vector(24, f32); +extern fn c_vector_24_f32(@Vector(24, f32), usize) void; +extern fn c_test_vector_24_f32() void; + +test "@Vector(24, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_24_f32(); + try expect(v[0] == 257); + try expect(v[1] == 258); + try expect(v[2] == 259); + try expect(v[3] == 260); + try expect(v[4] == 261); + try expect(v[5] == 262); + try expect(v[6] == 263); + try expect(v[7] == 264); + try expect(v[8] == 265); + try expect(v[9] == 266); + try expect(v[10] == 267); + try expect(v[11] == 268); + try expect(v[12] == 269); + try expect(v[13] == 270); + try expect(v[14] == 271); + try expect(v[15] == 272); + try expect(v[16] == 273); + try expect(v[17] == 274); + try expect(v[18] == 275); + try expect(v[19] == 276); + try expect(v[20] == 277); + try expect(v[21] == 278); + try expect(v[22] == 279); + try expect(v[23] == 280); + c_vector_24_f32(.{ + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, + }, 24); + c_test_vector_24_f32(); +} + +export fn zig_ret_vector_32_f32() @Vector(32, f32) { + return .{ + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + }; +} +export fn zig_vector_32_f32(v: @Vector(32, f32), i: usize) void { + expect(v[0] == 337) catch @panic("test failure"); + expect(v[1] == 338) catch @panic("test failure"); + expect(v[2] == 339) catch @panic("test failure"); + expect(v[3] == 340) catch @panic("test failure"); + expect(v[4] == 341) catch @panic("test failure"); + expect(v[5] == 342) catch @panic("test failure"); + expect(v[6] == 343) catch @panic("test failure"); + expect(v[7] == 344) catch @panic("test failure"); + expect(v[8] == 345) catch @panic("test failure"); + expect(v[9] == 346) catch @panic("test failure"); + expect(v[10] == 347) catch @panic("test failure"); + expect(v[11] == 348) catch @panic("test failure"); + expect(v[12] == 349) catch @panic("test failure"); + expect(v[13] == 350) catch @panic("test failure"); + expect(v[14] == 351) catch @panic("test failure"); + expect(v[15] == 352) catch @panic("test failure"); + expect(v[16] == 353) catch @panic("test failure"); + expect(v[17] == 354) catch @panic("test failure"); + expect(v[18] == 355) catch @panic("test failure"); + expect(v[19] == 356) catch @panic("test failure"); + expect(v[20] == 357) catch @panic("test failure"); + expect(v[21] == 358) catch @panic("test failure"); + expect(v[22] == 359) catch @panic("test failure"); + expect(v[23] == 360) catch @panic("test failure"); + expect(v[24] == 361) catch @panic("test failure"); + expect(v[25] == 362) catch @panic("test failure"); + expect(v[26] == 363) catch @panic("test failure"); + expect(v[27] == 364) catch @panic("test failure"); + expect(v[28] == 365) catch @panic("test failure"); + expect(v[29] == 366) catch @panic("test failure"); + expect(v[30] == 367) catch @panic("test failure"); + expect(v[31] == 368) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_f32() @Vector(32, f32); +extern fn c_vector_32_f32(@Vector(32, f32), usize) void; +extern fn c_test_vector_32_f32() void; + +test "@Vector(32, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_f32(); + try expect(v[0] == 369); + try expect(v[1] == 370); + try expect(v[2] == 371); + try expect(v[3] == 372); + try expect(v[4] == 373); + try expect(v[5] == 374); + try expect(v[6] == 375); + try expect(v[7] == 376); + try expect(v[8] == 377); + try expect(v[9] == 378); + try expect(v[10] == 379); + try expect(v[11] == 380); + try expect(v[12] == 381); + try expect(v[13] == 382); + try expect(v[14] == 383); + try expect(v[15] == 384); + try expect(v[16] == 385); + try expect(v[17] == 386); + try expect(v[18] == 387); + try expect(v[19] == 388); + try expect(v[20] == 389); + try expect(v[21] == 390); + try expect(v[22] == 391); + try expect(v[23] == 392); + try expect(v[24] == 393); + try expect(v[25] == 394); + try expect(v[26] == 395); + try expect(v[27] == 396); + try expect(v[28] == 397); + try expect(v[29] == 398); + try expect(v[30] == 399); + try expect(v[31] == 400); + c_vector_32_f32(.{ + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + }, 32); + c_test_vector_32_f32(); +} + +export fn zig_ret_vector_48_f32() @Vector(48, f32) { + return .{ + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + }; +} +export fn zig_vector_48_f32(v: @Vector(48, f32), i: usize) void { + expect(v[0] == 481) catch @panic("test failure"); + expect(v[1] == 482) catch @panic("test failure"); + expect(v[2] == 483) catch @panic("test failure"); + expect(v[3] == 484) catch @panic("test failure"); + expect(v[4] == 485) catch @panic("test failure"); + expect(v[5] == 486) catch @panic("test failure"); + expect(v[6] == 487) catch @panic("test failure"); + expect(v[7] == 488) catch @panic("test failure"); + expect(v[8] == 489) catch @panic("test failure"); + expect(v[9] == 490) catch @panic("test failure"); + expect(v[10] == 491) catch @panic("test failure"); + expect(v[11] == 492) catch @panic("test failure"); + expect(v[12] == 493) catch @panic("test failure"); + expect(v[13] == 494) catch @panic("test failure"); + expect(v[14] == 495) catch @panic("test failure"); + expect(v[15] == 496) catch @panic("test failure"); + expect(v[16] == 497) catch @panic("test failure"); + expect(v[17] == 498) catch @panic("test failure"); + expect(v[18] == 499) catch @panic("test failure"); + expect(v[19] == 500) catch @panic("test failure"); + expect(v[20] == 501) catch @panic("test failure"); + expect(v[21] == 502) catch @panic("test failure"); + expect(v[22] == 503) catch @panic("test failure"); + expect(v[23] == 504) catch @panic("test failure"); + expect(v[24] == 505) catch @panic("test failure"); + expect(v[25] == 506) catch @panic("test failure"); + expect(v[26] == 507) catch @panic("test failure"); + expect(v[27] == 508) catch @panic("test failure"); + expect(v[28] == 509) catch @panic("test failure"); + expect(v[29] == 510) catch @panic("test failure"); + expect(v[30] == 511) catch @panic("test failure"); + expect(v[31] == 512) catch @panic("test failure"); + expect(v[32] == 513) catch @panic("test failure"); + expect(v[33] == 514) catch @panic("test failure"); + expect(v[34] == 515) catch @panic("test failure"); + expect(v[35] == 516) catch @panic("test failure"); + expect(v[36] == 517) catch @panic("test failure"); + expect(v[37] == 518) catch @panic("test failure"); + expect(v[38] == 519) catch @panic("test failure"); + expect(v[39] == 520) catch @panic("test failure"); + expect(v[40] == 521) catch @panic("test failure"); + expect(v[41] == 522) catch @panic("test failure"); + expect(v[42] == 523) catch @panic("test failure"); + expect(v[43] == 524) catch @panic("test failure"); + expect(v[44] == 525) catch @panic("test failure"); + expect(v[45] == 526) catch @panic("test failure"); + expect(v[46] == 527) catch @panic("test failure"); + expect(v[47] == 528) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_f32() @Vector(48, f32); +extern fn c_vector_48_f32(@Vector(48, f32), usize) void; +extern fn c_test_vector_48_f32() void; + +test "@Vector(48, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_48_f32(); + try expect(v[0] == 529); + try expect(v[1] == 530); + try expect(v[2] == 531); + try expect(v[3] == 532); + try expect(v[4] == 533); + try expect(v[5] == 534); + try expect(v[6] == 535); + try expect(v[7] == 536); + try expect(v[8] == 537); + try expect(v[9] == 538); + try expect(v[10] == 539); + try expect(v[11] == 540); + try expect(v[12] == 541); + try expect(v[13] == 542); + try expect(v[14] == 543); + try expect(v[15] == 544); + try expect(v[16] == 545); + try expect(v[17] == 546); + try expect(v[18] == 547); + try expect(v[19] == 548); + try expect(v[20] == 549); + try expect(v[21] == 550); + try expect(v[22] == 551); + try expect(v[23] == 552); + try expect(v[24] == 553); + try expect(v[25] == 554); + try expect(v[26] == 555); + try expect(v[27] == 556); + try expect(v[28] == 557); + try expect(v[29] == 558); + try expect(v[30] == 559); + try expect(v[31] == 560); + try expect(v[32] == 561); + try expect(v[33] == 562); + try expect(v[34] == 563); + try expect(v[35] == 564); + try expect(v[36] == 565); + try expect(v[37] == 566); + try expect(v[38] == 567); + try expect(v[39] == 568); + try expect(v[40] == 569); + try expect(v[41] == 570); + try expect(v[42] == 571); + try expect(v[43] == 572); + try expect(v[44] == 573); + try expect(v[45] == 574); + try expect(v[46] == 575); + try expect(v[47] == 576); + c_vector_48_f32(.{ + 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, + 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, + 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + }, 48); + c_test_vector_48_f32(); +} + +export fn zig_ret_vector_64_f32() @Vector(64, f32) { + return .{ + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, + 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, + 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, + }; +} +export fn zig_vector_64_f32(v: @Vector(64, f32), i: usize) void { + expect(v[0] == 689) catch @panic("test failure"); + expect(v[1] == 690) catch @panic("test failure"); + expect(v[2] == 691) catch @panic("test failure"); + expect(v[3] == 692) catch @panic("test failure"); + expect(v[4] == 693) catch @panic("test failure"); + expect(v[5] == 694) catch @panic("test failure"); + expect(v[6] == 695) catch @panic("test failure"); + expect(v[7] == 696) catch @panic("test failure"); + expect(v[8] == 697) catch @panic("test failure"); + expect(v[9] == 698) catch @panic("test failure"); + expect(v[10] == 699) catch @panic("test failure"); + expect(v[11] == 700) catch @panic("test failure"); + expect(v[12] == 701) catch @panic("test failure"); + expect(v[13] == 702) catch @panic("test failure"); + expect(v[14] == 703) catch @panic("test failure"); + expect(v[15] == 704) catch @panic("test failure"); + expect(v[16] == 705) catch @panic("test failure"); + expect(v[17] == 706) catch @panic("test failure"); + expect(v[18] == 707) catch @panic("test failure"); + expect(v[19] == 708) catch @panic("test failure"); + expect(v[20] == 709) catch @panic("test failure"); + expect(v[21] == 710) catch @panic("test failure"); + expect(v[22] == 711) catch @panic("test failure"); + expect(v[23] == 712) catch @panic("test failure"); + expect(v[24] == 713) catch @panic("test failure"); + expect(v[25] == 714) catch @panic("test failure"); + expect(v[26] == 715) catch @panic("test failure"); + expect(v[27] == 716) catch @panic("test failure"); + expect(v[28] == 717) catch @panic("test failure"); + expect(v[29] == 718) catch @panic("test failure"); + expect(v[30] == 719) catch @panic("test failure"); + expect(v[31] == 720) catch @panic("test failure"); + expect(v[32] == 721) catch @panic("test failure"); + expect(v[33] == 722) catch @panic("test failure"); + expect(v[34] == 723) catch @panic("test failure"); + expect(v[35] == 724) catch @panic("test failure"); + expect(v[36] == 725) catch @panic("test failure"); + expect(v[37] == 726) catch @panic("test failure"); + expect(v[38] == 727) catch @panic("test failure"); + expect(v[39] == 728) catch @panic("test failure"); + expect(v[40] == 729) catch @panic("test failure"); + expect(v[41] == 730) catch @panic("test failure"); + expect(v[42] == 731) catch @panic("test failure"); + expect(v[43] == 732) catch @panic("test failure"); + expect(v[44] == 733) catch @panic("test failure"); + expect(v[45] == 734) catch @panic("test failure"); + expect(v[46] == 735) catch @panic("test failure"); + expect(v[47] == 736) catch @panic("test failure"); + expect(v[48] == 737) catch @panic("test failure"); + expect(v[49] == 738) catch @panic("test failure"); + expect(v[50] == 739) catch @panic("test failure"); + expect(v[51] == 740) catch @panic("test failure"); + expect(v[52] == 741) catch @panic("test failure"); + expect(v[53] == 742) catch @panic("test failure"); + expect(v[54] == 743) catch @panic("test failure"); + expect(v[55] == 744) catch @panic("test failure"); + expect(v[56] == 745) catch @panic("test failure"); + expect(v[57] == 746) catch @panic("test failure"); + expect(v[58] == 747) catch @panic("test failure"); + expect(v[59] == 748) catch @panic("test failure"); + expect(v[60] == 749) catch @panic("test failure"); + expect(v[61] == 750) catch @panic("test failure"); + expect(v[62] == 751) catch @panic("test failure"); + expect(v[63] == 752) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_f32() @Vector(64, f32); +extern fn c_vector_64_f32(@Vector(64, f32), usize) void; +extern fn c_test_vector_64_f32() void; + +test "@Vector(64, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_f32(); + try expect(v[0] == 753); + try expect(v[1] == 754); + try expect(v[2] == 755); + try expect(v[3] == 756); + try expect(v[4] == 757); + try expect(v[5] == 758); + try expect(v[6] == 759); + try expect(v[7] == 760); + try expect(v[8] == 761); + try expect(v[9] == 762); + try expect(v[10] == 763); + try expect(v[11] == 764); + try expect(v[12] == 765); + try expect(v[13] == 766); + try expect(v[14] == 767); + try expect(v[15] == 768); + try expect(v[16] == 769); + try expect(v[17] == 770); + try expect(v[18] == 771); + try expect(v[19] == 772); + try expect(v[20] == 773); + try expect(v[21] == 774); + try expect(v[22] == 775); + try expect(v[23] == 776); + try expect(v[24] == 777); + try expect(v[25] == 778); + try expect(v[26] == 779); + try expect(v[27] == 780); + try expect(v[28] == 781); + try expect(v[29] == 782); + try expect(v[30] == 783); + try expect(v[31] == 784); + try expect(v[32] == 785); + try expect(v[33] == 786); + try expect(v[34] == 787); + try expect(v[35] == 788); + try expect(v[36] == 789); + try expect(v[37] == 790); + try expect(v[38] == 791); + try expect(v[39] == 792); + try expect(v[40] == 793); + try expect(v[41] == 794); + try expect(v[42] == 795); + try expect(v[43] == 796); + try expect(v[44] == 797); + try expect(v[45] == 798); + try expect(v[46] == 799); + try expect(v[47] == 800); + try expect(v[48] == 801); + try expect(v[49] == 802); + try expect(v[50] == 803); + try expect(v[51] == 804); + try expect(v[52] == 805); + try expect(v[53] == 806); + try expect(v[54] == 807); + try expect(v[55] == 808); + try expect(v[56] == 809); + try expect(v[57] == 810); + try expect(v[58] == 811); + try expect(v[59] == 812); + try expect(v[60] == 813); + try expect(v[61] == 814); + try expect(v[62] == 815); + try expect(v[63] == 816); + c_vector_64_f32(.{ + 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, + }, 64); + c_test_vector_64_f32(); +} + +export fn zig_ret_vector_96_f32() @Vector(96, f32) { + return .{ + 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, + 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, + 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, + 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, + 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, + 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, + }; +} +export fn zig_vector_96_f32(v: @Vector(96, f32), i: usize) void { + expect(v[0] == 986) catch @panic("test failure"); + expect(v[1] == 987) catch @panic("test failure"); + expect(v[2] == 988) catch @panic("test failure"); + expect(v[3] == 989) catch @panic("test failure"); + expect(v[4] == 990) catch @panic("test failure"); + expect(v[5] == 991) catch @panic("test failure"); + expect(v[6] == 992) catch @panic("test failure"); + expect(v[7] == 993) catch @panic("test failure"); + expect(v[8] == 994) catch @panic("test failure"); + expect(v[9] == 995) catch @panic("test failure"); + expect(v[10] == 996) catch @panic("test failure"); + expect(v[11] == 997) catch @panic("test failure"); + expect(v[12] == 998) catch @panic("test failure"); + expect(v[13] == 999) catch @panic("test failure"); + expect(v[14] == 1000) catch @panic("test failure"); + expect(v[15] == 1001) catch @panic("test failure"); + expect(v[16] == 1002) catch @panic("test failure"); + expect(v[17] == 1003) catch @panic("test failure"); + expect(v[18] == 1004) catch @panic("test failure"); + expect(v[19] == 1005) catch @panic("test failure"); + expect(v[20] == 1006) catch @panic("test failure"); + expect(v[21] == 1007) catch @panic("test failure"); + expect(v[22] == 1008) catch @panic("test failure"); + expect(v[23] == 1009) catch @panic("test failure"); + expect(v[24] == 1010) catch @panic("test failure"); + expect(v[25] == 1011) catch @panic("test failure"); + expect(v[26] == 1012) catch @panic("test failure"); + expect(v[27] == 1013) catch @panic("test failure"); + expect(v[28] == 1014) catch @panic("test failure"); + expect(v[29] == 1015) catch @panic("test failure"); + expect(v[30] == 1016) catch @panic("test failure"); + expect(v[31] == 1017) catch @panic("test failure"); + expect(v[32] == 1018) catch @panic("test failure"); + expect(v[33] == 1019) catch @panic("test failure"); + expect(v[34] == 1020) catch @panic("test failure"); + expect(v[35] == 1021) catch @panic("test failure"); + expect(v[36] == 1022) catch @panic("test failure"); + expect(v[37] == 1023) catch @panic("test failure"); + expect(v[38] == 1024) catch @panic("test failure"); + expect(v[39] == 1025) catch @panic("test failure"); + expect(v[40] == 1026) catch @panic("test failure"); + expect(v[41] == 1027) catch @panic("test failure"); + expect(v[42] == 1028) catch @panic("test failure"); + expect(v[43] == 1029) catch @panic("test failure"); + expect(v[44] == 1030) catch @panic("test failure"); + expect(v[45] == 1031) catch @panic("test failure"); + expect(v[46] == 1032) catch @panic("test failure"); + expect(v[47] == 1033) catch @panic("test failure"); + expect(v[48] == 1034) catch @panic("test failure"); + expect(v[49] == 1035) catch @panic("test failure"); + expect(v[50] == 1036) catch @panic("test failure"); + expect(v[51] == 1037) catch @panic("test failure"); + expect(v[52] == 1038) catch @panic("test failure"); + expect(v[53] == 1039) catch @panic("test failure"); + expect(v[54] == 1040) catch @panic("test failure"); + expect(v[55] == 1041) catch @panic("test failure"); + expect(v[56] == 1042) catch @panic("test failure"); + expect(v[57] == 1043) catch @panic("test failure"); + expect(v[58] == 1044) catch @panic("test failure"); + expect(v[59] == 1045) catch @panic("test failure"); + expect(v[60] == 1046) catch @panic("test failure"); + expect(v[61] == 1047) catch @panic("test failure"); + expect(v[62] == 1048) catch @panic("test failure"); + expect(v[63] == 1049) catch @panic("test failure"); + expect(v[64] == 1050) catch @panic("test failure"); + expect(v[65] == 1051) catch @panic("test failure"); + expect(v[66] == 1052) catch @panic("test failure"); + expect(v[67] == 1053) catch @panic("test failure"); + expect(v[68] == 1054) catch @panic("test failure"); + expect(v[69] == 1055) catch @panic("test failure"); + expect(v[70] == 1056) catch @panic("test failure"); + expect(v[71] == 1057) catch @panic("test failure"); + expect(v[72] == 1058) catch @panic("test failure"); + expect(v[73] == 1059) catch @panic("test failure"); + expect(v[74] == 1060) catch @panic("test failure"); + expect(v[75] == 1061) catch @panic("test failure"); + expect(v[76] == 1062) catch @panic("test failure"); + expect(v[77] == 1063) catch @panic("test failure"); + expect(v[78] == 1064) catch @panic("test failure"); + expect(v[79] == 1065) catch @panic("test failure"); + expect(v[80] == 1066) catch @panic("test failure"); + expect(v[81] == 1067) catch @panic("test failure"); + expect(v[82] == 1068) catch @panic("test failure"); + expect(v[83] == 1069) catch @panic("test failure"); + expect(v[84] == 1070) catch @panic("test failure"); + expect(v[85] == 1071) catch @panic("test failure"); + expect(v[86] == 1072) catch @panic("test failure"); + expect(v[87] == 1073) catch @panic("test failure"); + expect(v[88] == 1074) catch @panic("test failure"); + expect(v[89] == 1075) catch @panic("test failure"); + expect(v[90] == 1076) catch @panic("test failure"); + expect(v[91] == 1077) catch @panic("test failure"); + expect(v[92] == 1078) catch @panic("test failure"); + expect(v[93] == 1079) catch @panic("test failure"); + expect(v[94] == 1080) catch @panic("test failure"); + expect(v[95] == 1081) catch @panic("test failure"); + expect(i == 96) catch @panic("test failure"); +} + +extern fn c_ret_vector_96_f32() @Vector(96, f32); +extern fn c_vector_96_f32(@Vector(96, f32), usize) void; +extern fn c_test_vector_96_f32() void; + +test "@Vector(96, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_96_f32(); + try expect(v[0] == 1082); + try expect(v[1] == 1083); + try expect(v[2] == 1084); + try expect(v[3] == 1085); + try expect(v[4] == 1086); + try expect(v[5] == 1087); + try expect(v[6] == 1088); + try expect(v[7] == 1089); + try expect(v[8] == 1090); + try expect(v[9] == 1091); + try expect(v[10] == 1092); + try expect(v[11] == 1093); + try expect(v[12] == 1094); + try expect(v[13] == 1095); + try expect(v[14] == 1096); + try expect(v[15] == 1097); + try expect(v[16] == 1098); + try expect(v[17] == 1099); + try expect(v[18] == 1100); + try expect(v[19] == 1101); + try expect(v[20] == 1102); + try expect(v[21] == 1103); + try expect(v[22] == 1104); + try expect(v[23] == 1105); + try expect(v[24] == 1106); + try expect(v[25] == 1107); + try expect(v[26] == 1108); + try expect(v[27] == 1109); + try expect(v[28] == 1110); + try expect(v[29] == 1111); + try expect(v[30] == 1112); + try expect(v[31] == 1113); + try expect(v[32] == 1114); + try expect(v[33] == 1115); + try expect(v[34] == 1116); + try expect(v[35] == 1117); + try expect(v[36] == 1118); + try expect(v[37] == 1119); + try expect(v[38] == 1120); + try expect(v[39] == 1121); + try expect(v[40] == 1122); + try expect(v[41] == 1123); + try expect(v[42] == 1124); + try expect(v[43] == 1125); + try expect(v[44] == 1126); + try expect(v[45] == 1127); + try expect(v[46] == 1128); + try expect(v[47] == 1129); + try expect(v[48] == 1130); + try expect(v[49] == 1131); + try expect(v[50] == 1132); + try expect(v[51] == 1133); + try expect(v[52] == 1134); + try expect(v[53] == 1135); + try expect(v[54] == 1136); + try expect(v[55] == 1137); + try expect(v[56] == 1138); + try expect(v[57] == 1139); + try expect(v[58] == 1140); + try expect(v[59] == 1141); + try expect(v[60] == 1142); + try expect(v[61] == 1143); + try expect(v[62] == 1144); + try expect(v[63] == 1145); + try expect(v[64] == 1146); + try expect(v[65] == 1147); + try expect(v[66] == 1148); + try expect(v[67] == 1149); + try expect(v[68] == 1150); + try expect(v[69] == 1151); + try expect(v[70] == 1152); + try expect(v[71] == 1153); + try expect(v[72] == 1154); + try expect(v[73] == 1155); + try expect(v[74] == 1156); + try expect(v[75] == 1157); + try expect(v[76] == 1158); + try expect(v[77] == 1159); + try expect(v[78] == 1160); + try expect(v[79] == 1161); + try expect(v[80] == 1162); + try expect(v[81] == 1163); + try expect(v[82] == 1164); + try expect(v[83] == 1165); + try expect(v[84] == 1166); + try expect(v[85] == 1167); + try expect(v[86] == 1168); + try expect(v[87] == 1169); + try expect(v[88] == 1170); + try expect(v[89] == 1171); + try expect(v[90] == 1172); + try expect(v[91] == 1173); + try expect(v[92] == 1174); + try expect(v[93] == 1175); + try expect(v[94] == 1176); + try expect(v[95] == 1177); + c_vector_96_f32(.{ + 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, + 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, + 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, + 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, + 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, + 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, + }, 96); + c_test_vector_96_f32(); +} + +export fn zig_ret_vector_128_f32() @Vector(128, f32) { + return .{ + 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, + 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, + 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, + 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, + 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, + 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, + 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, + 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, + }; +} +export fn zig_vector_128_f32(v: @Vector(128, f32), i: usize) void { + expect(v[0] == 1402) catch @panic("test failure"); + expect(v[1] == 1403) catch @panic("test failure"); + expect(v[2] == 1404) catch @panic("test failure"); + expect(v[3] == 1405) catch @panic("test failure"); + expect(v[4] == 1406) catch @panic("test failure"); + expect(v[5] == 1407) catch @panic("test failure"); + expect(v[6] == 1408) catch @panic("test failure"); + expect(v[7] == 1409) catch @panic("test failure"); + expect(v[8] == 1410) catch @panic("test failure"); + expect(v[9] == 1411) catch @panic("test failure"); + expect(v[10] == 1412) catch @panic("test failure"); + expect(v[11] == 1413) catch @panic("test failure"); + expect(v[12] == 1414) catch @panic("test failure"); + expect(v[13] == 1415) catch @panic("test failure"); + expect(v[14] == 1416) catch @panic("test failure"); + expect(v[15] == 1417) catch @panic("test failure"); + expect(v[16] == 1418) catch @panic("test failure"); + expect(v[17] == 1419) catch @panic("test failure"); + expect(v[18] == 1420) catch @panic("test failure"); + expect(v[19] == 1421) catch @panic("test failure"); + expect(v[20] == 1422) catch @panic("test failure"); + expect(v[21] == 1423) catch @panic("test failure"); + expect(v[22] == 1424) catch @panic("test failure"); + expect(v[23] == 1425) catch @panic("test failure"); + expect(v[24] == 1426) catch @panic("test failure"); + expect(v[25] == 1427) catch @panic("test failure"); + expect(v[26] == 1428) catch @panic("test failure"); + expect(v[27] == 1429) catch @panic("test failure"); + expect(v[28] == 1430) catch @panic("test failure"); + expect(v[29] == 1431) catch @panic("test failure"); + expect(v[30] == 1432) catch @panic("test failure"); + expect(v[31] == 1433) catch @panic("test failure"); + expect(v[32] == 1434) catch @panic("test failure"); + expect(v[33] == 1435) catch @panic("test failure"); + expect(v[34] == 1436) catch @panic("test failure"); + expect(v[35] == 1437) catch @panic("test failure"); + expect(v[36] == 1438) catch @panic("test failure"); + expect(v[37] == 1439) catch @panic("test failure"); + expect(v[38] == 1440) catch @panic("test failure"); + expect(v[39] == 1441) catch @panic("test failure"); + expect(v[40] == 1442) catch @panic("test failure"); + expect(v[41] == 1443) catch @panic("test failure"); + expect(v[42] == 1444) catch @panic("test failure"); + expect(v[43] == 1445) catch @panic("test failure"); + expect(v[44] == 1446) catch @panic("test failure"); + expect(v[45] == 1447) catch @panic("test failure"); + expect(v[46] == 1448) catch @panic("test failure"); + expect(v[47] == 1449) catch @panic("test failure"); + expect(v[48] == 1450) catch @panic("test failure"); + expect(v[49] == 1451) catch @panic("test failure"); + expect(v[50] == 1452) catch @panic("test failure"); + expect(v[51] == 1453) catch @panic("test failure"); + expect(v[52] == 1454) catch @panic("test failure"); + expect(v[53] == 1455) catch @panic("test failure"); + expect(v[54] == 1456) catch @panic("test failure"); + expect(v[55] == 1457) catch @panic("test failure"); + expect(v[56] == 1458) catch @panic("test failure"); + expect(v[57] == 1459) catch @panic("test failure"); + expect(v[58] == 1460) catch @panic("test failure"); + expect(v[59] == 1461) catch @panic("test failure"); + expect(v[60] == 1462) catch @panic("test failure"); + expect(v[61] == 1463) catch @panic("test failure"); + expect(v[62] == 1464) catch @panic("test failure"); + expect(v[63] == 1465) catch @panic("test failure"); + expect(v[64] == 1466) catch @panic("test failure"); + expect(v[65] == 1467) catch @panic("test failure"); + expect(v[66] == 1468) catch @panic("test failure"); + expect(v[67] == 1469) catch @panic("test failure"); + expect(v[68] == 1470) catch @panic("test failure"); + expect(v[69] == 1471) catch @panic("test failure"); + expect(v[70] == 1472) catch @panic("test failure"); + expect(v[71] == 1473) catch @panic("test failure"); + expect(v[72] == 1474) catch @panic("test failure"); + expect(v[73] == 1475) catch @panic("test failure"); + expect(v[74] == 1476) catch @panic("test failure"); + expect(v[75] == 1477) catch @panic("test failure"); + expect(v[76] == 1478) catch @panic("test failure"); + expect(v[77] == 1479) catch @panic("test failure"); + expect(v[78] == 1480) catch @panic("test failure"); + expect(v[79] == 1481) catch @panic("test failure"); + expect(v[80] == 1482) catch @panic("test failure"); + expect(v[81] == 1483) catch @panic("test failure"); + expect(v[82] == 1484) catch @panic("test failure"); + expect(v[83] == 1485) catch @panic("test failure"); + expect(v[84] == 1486) catch @panic("test failure"); + expect(v[85] == 1487) catch @panic("test failure"); + expect(v[86] == 1488) catch @panic("test failure"); + expect(v[87] == 1489) catch @panic("test failure"); + expect(v[88] == 1490) catch @panic("test failure"); + expect(v[89] == 1491) catch @panic("test failure"); + expect(v[90] == 1492) catch @panic("test failure"); + expect(v[91] == 1493) catch @panic("test failure"); + expect(v[92] == 1494) catch @panic("test failure"); + expect(v[93] == 1495) catch @panic("test failure"); + expect(v[94] == 1496) catch @panic("test failure"); + expect(v[95] == 1497) catch @panic("test failure"); + expect(v[96] == 1498) catch @panic("test failure"); + expect(v[97] == 1499) catch @panic("test failure"); + expect(v[98] == 1500) catch @panic("test failure"); + expect(v[99] == 1501) catch @panic("test failure"); + expect(v[100] == 1502) catch @panic("test failure"); + expect(v[101] == 1503) catch @panic("test failure"); + expect(v[102] == 1504) catch @panic("test failure"); + expect(v[103] == 1505) catch @panic("test failure"); + expect(v[104] == 1506) catch @panic("test failure"); + expect(v[105] == 1507) catch @panic("test failure"); + expect(v[106] == 1508) catch @panic("test failure"); + expect(v[107] == 1509) catch @panic("test failure"); + expect(v[108] == 1510) catch @panic("test failure"); + expect(v[109] == 1511) catch @panic("test failure"); + expect(v[110] == 1512) catch @panic("test failure"); + expect(v[111] == 1513) catch @panic("test failure"); + expect(v[112] == 1514) catch @panic("test failure"); + expect(v[113] == 1515) catch @panic("test failure"); + expect(v[114] == 1516) catch @panic("test failure"); + expect(v[115] == 1517) catch @panic("test failure"); + expect(v[116] == 1518) catch @panic("test failure"); + expect(v[117] == 1519) catch @panic("test failure"); + expect(v[118] == 1520) catch @panic("test failure"); + expect(v[119] == 1521) catch @panic("test failure"); + expect(v[120] == 1522) catch @panic("test failure"); + expect(v[121] == 1523) catch @panic("test failure"); + expect(v[122] == 1524) catch @panic("test failure"); + expect(v[123] == 1525) catch @panic("test failure"); + expect(v[124] == 1526) catch @panic("test failure"); + expect(v[125] == 1527) catch @panic("test failure"); + expect(v[126] == 1528) catch @panic("test failure"); + expect(v[127] == 1529) catch @panic("test failure"); + expect(i == 128) catch @panic("test failure"); +} + +extern fn c_ret_vector_128_f32() @Vector(128, f32); +extern fn c_vector_128_f32(@Vector(128, f32), usize) void; +extern fn c_test_vector_128_f32() void; + +test "@Vector(128, f32)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_128_f32(); + try expect(v[0] == 1530); + try expect(v[1] == 1531); + try expect(v[2] == 1532); + try expect(v[3] == 1533); + try expect(v[4] == 1534); + try expect(v[5] == 1535); + try expect(v[6] == 1536); + try expect(v[7] == 1537); + try expect(v[8] == 1538); + try expect(v[9] == 1539); + try expect(v[10] == 1540); + try expect(v[11] == 1541); + try expect(v[12] == 1542); + try expect(v[13] == 1543); + try expect(v[14] == 1544); + try expect(v[15] == 1545); + try expect(v[16] == 1546); + try expect(v[17] == 1547); + try expect(v[18] == 1548); + try expect(v[19] == 1549); + try expect(v[20] == 1550); + try expect(v[21] == 1551); + try expect(v[22] == 1552); + try expect(v[23] == 1553); + try expect(v[24] == 1554); + try expect(v[25] == 1555); + try expect(v[26] == 1556); + try expect(v[27] == 1557); + try expect(v[28] == 1558); + try expect(v[29] == 1559); + try expect(v[30] == 1560); + try expect(v[31] == 1561); + try expect(v[32] == 1562); + try expect(v[33] == 1563); + try expect(v[34] == 1564); + try expect(v[35] == 1565); + try expect(v[36] == 1566); + try expect(v[37] == 1567); + try expect(v[38] == 1568); + try expect(v[39] == 1569); + try expect(v[40] == 1570); + try expect(v[41] == 1571); + try expect(v[42] == 1572); + try expect(v[43] == 1573); + try expect(v[44] == 1574); + try expect(v[45] == 1575); + try expect(v[46] == 1576); + try expect(v[47] == 1577); + try expect(v[48] == 1578); + try expect(v[49] == 1579); + try expect(v[50] == 1580); + try expect(v[51] == 1581); + try expect(v[52] == 1582); + try expect(v[53] == 1583); + try expect(v[54] == 1584); + try expect(v[55] == 1585); + try expect(v[56] == 1586); + try expect(v[57] == 1587); + try expect(v[58] == 1588); + try expect(v[59] == 1589); + try expect(v[60] == 1590); + try expect(v[61] == 1591); + try expect(v[62] == 1592); + try expect(v[63] == 1593); + try expect(v[64] == 1594); + try expect(v[65] == 1595); + try expect(v[66] == 1596); + try expect(v[67] == 1597); + try expect(v[68] == 1598); + try expect(v[69] == 1599); + try expect(v[70] == 1600); + try expect(v[71] == 1601); + try expect(v[72] == 1602); + try expect(v[73] == 1603); + try expect(v[74] == 1604); + try expect(v[75] == 1605); + try expect(v[76] == 1606); + try expect(v[77] == 1607); + try expect(v[78] == 1608); + try expect(v[79] == 1609); + try expect(v[80] == 1610); + try expect(v[81] == 1611); + try expect(v[82] == 1612); + try expect(v[83] == 1613); + try expect(v[84] == 1614); + try expect(v[85] == 1615); + try expect(v[86] == 1616); + try expect(v[87] == 1617); + try expect(v[88] == 1618); + try expect(v[89] == 1619); + try expect(v[90] == 1620); + try expect(v[91] == 1621); + try expect(v[92] == 1622); + try expect(v[93] == 1623); + try expect(v[94] == 1624); + try expect(v[95] == 1625); + try expect(v[96] == 1626); + try expect(v[97] == 1627); + try expect(v[98] == 1628); + try expect(v[99] == 1629); + try expect(v[100] == 1630); + try expect(v[101] == 1631); + try expect(v[102] == 1632); + try expect(v[103] == 1633); + try expect(v[104] == 1634); + try expect(v[105] == 1635); + try expect(v[106] == 1636); + try expect(v[107] == 1637); + try expect(v[108] == 1638); + try expect(v[109] == 1639); + try expect(v[110] == 1640); + try expect(v[111] == 1641); + try expect(v[112] == 1642); + try expect(v[113] == 1643); + try expect(v[114] == 1644); + try expect(v[115] == 1645); + try expect(v[116] == 1646); + try expect(v[117] == 1647); + try expect(v[118] == 1648); + try expect(v[119] == 1649); + try expect(v[120] == 1650); + try expect(v[121] == 1651); + try expect(v[122] == 1652); + try expect(v[123] == 1653); + try expect(v[124] == 1654); + try expect(v[125] == 1655); + try expect(v[126] == 1656); + try expect(v[127] == 1657); + c_vector_128_f32(.{ + 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, + 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, + 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, + 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, + 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, + 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753, + 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, + 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, + }, 128); + c_test_vector_128_f32(); +} + +export fn zig_ret_vector_1_f64() @Vector(1, f64) { + return .{1}; +} +export fn zig_vector_1_f64(v: @Vector(1, f64), i: usize) void { + expect(v[0] == 2) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} + +extern fn c_ret_vector_1_f64() @Vector(1, f64); +extern fn c_vector_1_f64(@Vector(1, f64), usize) void; +extern fn c_test_vector_1_f64() void; + +test "@Vector(1, f64)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + + const v = c_ret_vector_1_f64(); + try expect(v[0] == 3); + c_vector_1_f64(.{4}, 1); + c_test_vector_1_f64(); +} + +export fn zig_ret_vector_2_f64() @Vector(2, f64) { + return .{ 5, 6 }; +} +export fn zig_vector_2_f64(v: @Vector(2, f64), i: usize) void { + expect(v[0] == 7) catch @panic("test failure"); + expect(v[1] == 8) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} + +extern fn c_ret_vector_2_f64() @Vector(2, f64); +extern fn c_vector_2_f64(@Vector(2, f64), usize) void; +extern fn c_test_vector_2_f64() void; + +test "@Vector(2, f64)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + + const v = c_ret_vector_2_f64(); + try expect(v[0] == 9); + try expect(v[1] == 10); + c_vector_2_f64(.{ 11, 12 }, 2); + c_test_vector_2_f64(); +} + +export fn zig_ret_vector_3_f64() @Vector(3, f64) { + return .{ 13, 14, 15 }; +} +export fn zig_vector_3_f64(v: @Vector(3, f64), i: usize) void { + expect(v[0] == 16) catch @panic("test failure"); + expect(v[1] == 17) catch @panic("test failure"); + expect(v[2] == 18) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_vector_3_f64() @Vector(3, f64); +extern fn c_vector_3_f64(@Vector(3, f64), usize) void; +extern fn c_test_vector_3_f64() void; + +test "@Vector(3, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_3_f64(); + try expect(v[0] == 19); + try expect(v[1] == 20); + try expect(v[2] == 21); + c_vector_3_f64(.{ 22, 23, 24 }, 3); + c_test_vector_3_f64(); +} + +export fn zig_ret_vector_4_f64() @Vector(4, f64) { + return .{ 25, 26, 27, 28 }; +} +export fn zig_vector_4_f64(v: @Vector(4, f64), i: usize) void { + expect(v[0] == 29) catch @panic("test failure"); + expect(v[1] == 30) catch @panic("test failure"); + expect(v[2] == 31) catch @panic("test failure"); + expect(v[3] == 32) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} + +extern fn c_ret_vector_4_f64() @Vector(4, f64); +extern fn c_vector_4_f64(@Vector(4, f64), usize) void; +extern fn c_test_vector_4_f64() void; + +test "@Vector(4, f64)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_4_f64(); + try expect(v[0] == 33); + try expect(v[1] == 34); + try expect(v[2] == 35); + try expect(v[3] == 36); + c_vector_4_f64(.{ 37, 38, 39, 40 }, 4); + c_test_vector_4_f64(); +} + +export fn zig_ret_vector_6_f64() @Vector(6, f64) { + return .{ 41, 42, 43, 44, 45, 46 }; +} +export fn zig_vector_6_f64(v: @Vector(6, f64), i: usize) void { + expect(v[0] == 47) catch @panic("test failure"); + expect(v[1] == 48) catch @panic("test failure"); + expect(v[2] == 49) catch @panic("test failure"); + expect(v[3] == 50) catch @panic("test failure"); + expect(v[4] == 51) catch @panic("test failure"); + expect(v[5] == 52) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} + +extern fn c_ret_vector_6_f64() @Vector(6, f64); +extern fn c_vector_6_f64(@Vector(6, f64), usize) void; +extern fn c_test_vector_6_f64() void; + +test "@Vector(6, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_6_f64(); + try expect(v[0] == 53); + try expect(v[1] == 54); + try expect(v[2] == 55); + try expect(v[3] == 56); + try expect(v[4] == 57); + try expect(v[5] == 58); + c_vector_6_f64(.{ 59, 60, 61, 62, 63, 64 }, 6); + c_test_vector_6_f64(); +} + +export fn zig_ret_vector_8_f64() @Vector(8, f64) { + return .{ 65, 66, 67, 68, 69, 70, 71, 72 }; +} +export fn zig_vector_8_f64(v: @Vector(8, f64), i: usize) void { + expect(v[0] == 73) catch @panic("test failure"); + expect(v[1] == 74) catch @panic("test failure"); + expect(v[2] == 75) catch @panic("test failure"); + expect(v[3] == 76) catch @panic("test failure"); + expect(v[4] == 77) catch @panic("test failure"); + expect(v[5] == 78) catch @panic("test failure"); + expect(v[6] == 79) catch @panic("test failure"); + expect(v[7] == 80) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} + +extern fn c_ret_vector_8_f64() @Vector(8, f64); +extern fn c_vector_8_f64(@Vector(8, f64), usize) void; +extern fn c_test_vector_8_f64() void; + +test "@Vector(8, f64)" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_8_f64(); + try expect(v[0] == 81); + try expect(v[1] == 82); + try expect(v[2] == 83); + try expect(v[3] == 84); + try expect(v[4] == 85); + try expect(v[5] == 86); + try expect(v[6] == 87); + try expect(v[7] == 88); + c_vector_8_f64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8); + c_test_vector_8_f64(); +} + +export fn zig_ret_vector_12_f64() @Vector(12, f64) { + return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 }; +} +export fn zig_vector_12_f64(v: @Vector(12, f64), i: usize) void { + expect(v[0] == 109) catch @panic("test failure"); + expect(v[1] == 110) catch @panic("test failure"); + expect(v[2] == 111) catch @panic("test failure"); + expect(v[3] == 112) catch @panic("test failure"); + expect(v[4] == 113) catch @panic("test failure"); + expect(v[5] == 114) catch @panic("test failure"); + expect(v[6] == 115) catch @panic("test failure"); + expect(v[7] == 116) catch @panic("test failure"); + expect(v[8] == 117) catch @panic("test failure"); + expect(v[9] == 118) catch @panic("test failure"); + expect(v[10] == 119) catch @panic("test failure"); + expect(v[11] == 120) catch @panic("test failure"); + expect(i == 12) catch @panic("test failure"); +} + +extern fn c_ret_vector_12_f64() @Vector(12, f64); +extern fn c_vector_12_f64(@Vector(12, f64), usize) void; +extern fn c_test_vector_12_f64() void; + +test "@Vector(12, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_12_f64(); + try expect(v[0] == 121); + try expect(v[1] == 122); + try expect(v[2] == 123); + try expect(v[3] == 124); + try expect(v[4] == 125); + try expect(v[5] == 126); + try expect(v[6] == 127); + try expect(v[7] == 128); + try expect(v[8] == 129); + try expect(v[9] == 130); + try expect(v[10] == 131); + try expect(v[11] == 132); + c_vector_12_f64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12); + c_test_vector_12_f64(); +} + +export fn zig_ret_vector_16_f64() @Vector(16, f64) { + return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 }; +} +export fn zig_vector_16_f64(v: @Vector(16, f64), i: usize) void { + expect(v[0] == 161) catch @panic("test failure"); + expect(v[1] == 162) catch @panic("test failure"); + expect(v[2] == 163) catch @panic("test failure"); + expect(v[3] == 164) catch @panic("test failure"); + expect(v[4] == 165) catch @panic("test failure"); + expect(v[5] == 166) catch @panic("test failure"); + expect(v[6] == 167) catch @panic("test failure"); + expect(v[7] == 168) catch @panic("test failure"); + expect(v[8] == 169) catch @panic("test failure"); + expect(v[9] == 170) catch @panic("test failure"); + expect(v[10] == 171) catch @panic("test failure"); + expect(v[11] == 172) catch @panic("test failure"); + expect(v[12] == 173) catch @panic("test failure"); + expect(v[13] == 174) catch @panic("test failure"); + expect(v[14] == 175) catch @panic("test failure"); + expect(v[15] == 176) catch @panic("test failure"); + expect(i == 16) catch @panic("test failure"); +} + +extern fn c_ret_vector_16_f64() @Vector(16, f64); +extern fn c_vector_16_f64(@Vector(16, f64), usize) void; +extern fn c_test_vector_16_f64() void; + +test "@Vector(16, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_16_f64(); + try expect(v[0] == 177); + try expect(v[1] == 178); + try expect(v[2] == 179); + try expect(v[3] == 180); + try expect(v[4] == 181); + try expect(v[5] == 182); + try expect(v[6] == 183); + try expect(v[7] == 184); + try expect(v[8] == 185); + try expect(v[9] == 186); + try expect(v[10] == 187); + try expect(v[11] == 188); + try expect(v[12] == 189); + try expect(v[13] == 190); + try expect(v[14] == 191); + try expect(v[15] == 192); + c_vector_16_f64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16); + c_test_vector_16_f64(); +} + +export fn zig_ret_vector_24_f64() @Vector(24, f64) { + return .{ + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, + }; +} +export fn zig_vector_24_f64(v: @Vector(24, f64), i: usize) void { + expect(v[0] == 233) catch @panic("test failure"); + expect(v[1] == 234) catch @panic("test failure"); + expect(v[2] == 235) catch @panic("test failure"); + expect(v[3] == 236) catch @panic("test failure"); + expect(v[4] == 237) catch @panic("test failure"); + expect(v[5] == 238) catch @panic("test failure"); + expect(v[6] == 239) catch @panic("test failure"); + expect(v[7] == 240) catch @panic("test failure"); + expect(v[8] == 241) catch @panic("test failure"); + expect(v[9] == 242) catch @panic("test failure"); + expect(v[10] == 243) catch @panic("test failure"); + expect(v[11] == 244) catch @panic("test failure"); + expect(v[12] == 245) catch @panic("test failure"); + expect(v[13] == 246) catch @panic("test failure"); + expect(v[14] == 247) catch @panic("test failure"); + expect(v[15] == 248) catch @panic("test failure"); + expect(v[16] == 249) catch @panic("test failure"); + expect(v[17] == 250) catch @panic("test failure"); + expect(v[18] == 251) catch @panic("test failure"); + expect(v[19] == 252) catch @panic("test failure"); + expect(v[20] == 253) catch @panic("test failure"); + expect(v[21] == 254) catch @panic("test failure"); + expect(v[22] == 255) catch @panic("test failure"); + expect(v[23] == 256) catch @panic("test failure"); + expect(i == 24) catch @panic("test failure"); +} + +extern fn c_ret_vector_24_f64() @Vector(24, f64); +extern fn c_vector_24_f64(@Vector(24, f64), usize) void; +extern fn c_test_vector_24_f64() void; + +test "@Vector(24, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_24_f64(); + try expect(v[0] == 257); + try expect(v[1] == 258); + try expect(v[2] == 259); + try expect(v[3] == 260); + try expect(v[4] == 261); + try expect(v[5] == 262); + try expect(v[6] == 263); + try expect(v[7] == 264); + try expect(v[8] == 265); + try expect(v[9] == 266); + try expect(v[10] == 267); + try expect(v[11] == 268); + try expect(v[12] == 269); + try expect(v[13] == 270); + try expect(v[14] == 271); + try expect(v[15] == 272); + try expect(v[16] == 273); + try expect(v[17] == 274); + try expect(v[18] == 275); + try expect(v[19] == 276); + try expect(v[20] == 277); + try expect(v[21] == 278); + try expect(v[22] == 279); + try expect(v[23] == 280); + c_vector_24_f64(.{ + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, + }, 24); + c_test_vector_24_f64(); +} + +export fn zig_ret_vector_32_f64() @Vector(32, f64) { + return .{ + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, + }; +} +export fn zig_vector_32_f64(v: @Vector(32, f64), i: usize) void { + expect(v[0] == 337) catch @panic("test failure"); + expect(v[1] == 338) catch @panic("test failure"); + expect(v[2] == 339) catch @panic("test failure"); + expect(v[3] == 340) catch @panic("test failure"); + expect(v[4] == 341) catch @panic("test failure"); + expect(v[5] == 342) catch @panic("test failure"); + expect(v[6] == 343) catch @panic("test failure"); + expect(v[7] == 344) catch @panic("test failure"); + expect(v[8] == 345) catch @panic("test failure"); + expect(v[9] == 346) catch @panic("test failure"); + expect(v[10] == 347) catch @panic("test failure"); + expect(v[11] == 348) catch @panic("test failure"); + expect(v[12] == 349) catch @panic("test failure"); + expect(v[13] == 350) catch @panic("test failure"); + expect(v[14] == 351) catch @panic("test failure"); + expect(v[15] == 352) catch @panic("test failure"); + expect(v[16] == 353) catch @panic("test failure"); + expect(v[17] == 354) catch @panic("test failure"); + expect(v[18] == 355) catch @panic("test failure"); + expect(v[19] == 356) catch @panic("test failure"); + expect(v[20] == 357) catch @panic("test failure"); + expect(v[21] == 358) catch @panic("test failure"); + expect(v[22] == 359) catch @panic("test failure"); + expect(v[23] == 360) catch @panic("test failure"); + expect(v[24] == 361) catch @panic("test failure"); + expect(v[25] == 362) catch @panic("test failure"); + expect(v[26] == 363) catch @panic("test failure"); + expect(v[27] == 364) catch @panic("test failure"); + expect(v[28] == 365) catch @panic("test failure"); + expect(v[29] == 366) catch @panic("test failure"); + expect(v[30] == 367) catch @panic("test failure"); + expect(v[31] == 368) catch @panic("test failure"); + expect(i == 32) catch @panic("test failure"); +} + +extern fn c_ret_vector_32_f64() @Vector(32, f64); +extern fn c_vector_32_f64(@Vector(32, f64), usize) void; +extern fn c_test_vector_32_f64() void; + +test "@Vector(32, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_32_f64(); + try expect(v[0] == 369); + try expect(v[1] == 370); + try expect(v[2] == 371); + try expect(v[3] == 372); + try expect(v[4] == 373); + try expect(v[5] == 374); + try expect(v[6] == 375); + try expect(v[7] == 376); + try expect(v[8] == 377); + try expect(v[9] == 378); + try expect(v[10] == 379); + try expect(v[11] == 380); + try expect(v[12] == 381); + try expect(v[13] == 382); + try expect(v[14] == 383); + try expect(v[15] == 384); + try expect(v[16] == 385); + try expect(v[17] == 386); + try expect(v[18] == 387); + try expect(v[19] == 388); + try expect(v[20] == 389); + try expect(v[21] == 390); + try expect(v[22] == 391); + try expect(v[23] == 392); + try expect(v[24] == 393); + try expect(v[25] == 394); + try expect(v[26] == 395); + try expect(v[27] == 396); + try expect(v[28] == 397); + try expect(v[29] == 398); + try expect(v[30] == 399); + try expect(v[31] == 400); + c_vector_32_f64(.{ + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + }, 32); + c_test_vector_32_f64(); +} + +export fn zig_ret_vector_48_f64() @Vector(48, f64) { + return .{ + 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + }; +} +export fn zig_vector_48_f64(v: @Vector(48, f64), i: usize) void { + expect(v[0] == 481) catch @panic("test failure"); + expect(v[1] == 482) catch @panic("test failure"); + expect(v[2] == 483) catch @panic("test failure"); + expect(v[3] == 484) catch @panic("test failure"); + expect(v[4] == 485) catch @panic("test failure"); + expect(v[5] == 486) catch @panic("test failure"); + expect(v[6] == 487) catch @panic("test failure"); + expect(v[7] == 488) catch @panic("test failure"); + expect(v[8] == 489) catch @panic("test failure"); + expect(v[9] == 490) catch @panic("test failure"); + expect(v[10] == 491) catch @panic("test failure"); + expect(v[11] == 492) catch @panic("test failure"); + expect(v[12] == 493) catch @panic("test failure"); + expect(v[13] == 494) catch @panic("test failure"); + expect(v[14] == 495) catch @panic("test failure"); + expect(v[15] == 496) catch @panic("test failure"); + expect(v[16] == 497) catch @panic("test failure"); + expect(v[17] == 498) catch @panic("test failure"); + expect(v[18] == 499) catch @panic("test failure"); + expect(v[19] == 500) catch @panic("test failure"); + expect(v[20] == 501) catch @panic("test failure"); + expect(v[21] == 502) catch @panic("test failure"); + expect(v[22] == 503) catch @panic("test failure"); + expect(v[23] == 504) catch @panic("test failure"); + expect(v[24] == 505) catch @panic("test failure"); + expect(v[25] == 506) catch @panic("test failure"); + expect(v[26] == 507) catch @panic("test failure"); + expect(v[27] == 508) catch @panic("test failure"); + expect(v[28] == 509) catch @panic("test failure"); + expect(v[29] == 510) catch @panic("test failure"); + expect(v[30] == 511) catch @panic("test failure"); + expect(v[31] == 512) catch @panic("test failure"); + expect(v[32] == 513) catch @panic("test failure"); + expect(v[33] == 514) catch @panic("test failure"); + expect(v[34] == 515) catch @panic("test failure"); + expect(v[35] == 516) catch @panic("test failure"); + expect(v[36] == 517) catch @panic("test failure"); + expect(v[37] == 518) catch @panic("test failure"); + expect(v[38] == 519) catch @panic("test failure"); + expect(v[39] == 520) catch @panic("test failure"); + expect(v[40] == 521) catch @panic("test failure"); + expect(v[41] == 522) catch @panic("test failure"); + expect(v[42] == 523) catch @panic("test failure"); + expect(v[43] == 524) catch @panic("test failure"); + expect(v[44] == 525) catch @panic("test failure"); + expect(v[45] == 526) catch @panic("test failure"); + expect(v[46] == 527) catch @panic("test failure"); + expect(v[47] == 528) catch @panic("test failure"); + expect(i == 48) catch @panic("test failure"); +} + +extern fn c_ret_vector_48_f64() @Vector(48, f64); +extern fn c_vector_48_f64(@Vector(48, f64), usize) void; +extern fn c_test_vector_48_f64() void; + +test "@Vector(48, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_48_f64(); + try expect(v[0] == 529); + try expect(v[1] == 530); + try expect(v[2] == 531); + try expect(v[3] == 532); + try expect(v[4] == 533); + try expect(v[5] == 534); + try expect(v[6] == 535); + try expect(v[7] == 536); + try expect(v[8] == 537); + try expect(v[9] == 538); + try expect(v[10] == 539); + try expect(v[11] == 540); + try expect(v[12] == 541); + try expect(v[13] == 542); + try expect(v[14] == 543); + try expect(v[15] == 544); + try expect(v[16] == 545); + try expect(v[17] == 546); + try expect(v[18] == 547); + try expect(v[19] == 548); + try expect(v[20] == 549); + try expect(v[21] == 550); + try expect(v[22] == 551); + try expect(v[23] == 552); + try expect(v[24] == 553); + try expect(v[25] == 554); + try expect(v[26] == 555); + try expect(v[27] == 556); + try expect(v[28] == 557); + try expect(v[29] == 558); + try expect(v[30] == 559); + try expect(v[31] == 560); + try expect(v[32] == 561); + try expect(v[33] == 562); + try expect(v[34] == 563); + try expect(v[35] == 564); + try expect(v[36] == 565); + try expect(v[37] == 566); + try expect(v[38] == 567); + try expect(v[39] == 568); + try expect(v[40] == 569); + try expect(v[41] == 570); + try expect(v[42] == 571); + try expect(v[43] == 572); + try expect(v[44] == 573); + try expect(v[45] == 574); + try expect(v[46] == 575); + try expect(v[47] == 576); + c_vector_48_f64(.{ + 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, + 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, + 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, + }, 48); + c_test_vector_48_f64(); +} + +export fn zig_ret_vector_64_f64() @Vector(64, f64) { + return .{ + 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, + 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, + 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, + 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, + }; +} +export fn zig_vector_64_f64(v: @Vector(64, f64), i: usize) void { + expect(v[0] == 689) catch @panic("test failure"); + expect(v[1] == 690) catch @panic("test failure"); + expect(v[2] == 691) catch @panic("test failure"); + expect(v[3] == 692) catch @panic("test failure"); + expect(v[4] == 693) catch @panic("test failure"); + expect(v[5] == 694) catch @panic("test failure"); + expect(v[6] == 695) catch @panic("test failure"); + expect(v[7] == 696) catch @panic("test failure"); + expect(v[8] == 697) catch @panic("test failure"); + expect(v[9] == 698) catch @panic("test failure"); + expect(v[10] == 699) catch @panic("test failure"); + expect(v[11] == 700) catch @panic("test failure"); + expect(v[12] == 701) catch @panic("test failure"); + expect(v[13] == 702) catch @panic("test failure"); + expect(v[14] == 703) catch @panic("test failure"); + expect(v[15] == 704) catch @panic("test failure"); + expect(v[16] == 705) catch @panic("test failure"); + expect(v[17] == 706) catch @panic("test failure"); + expect(v[18] == 707) catch @panic("test failure"); + expect(v[19] == 708) catch @panic("test failure"); + expect(v[20] == 709) catch @panic("test failure"); + expect(v[21] == 710) catch @panic("test failure"); + expect(v[22] == 711) catch @panic("test failure"); + expect(v[23] == 712) catch @panic("test failure"); + expect(v[24] == 713) catch @panic("test failure"); + expect(v[25] == 714) catch @panic("test failure"); + expect(v[26] == 715) catch @panic("test failure"); + expect(v[27] == 716) catch @panic("test failure"); + expect(v[28] == 717) catch @panic("test failure"); + expect(v[29] == 718) catch @panic("test failure"); + expect(v[30] == 719) catch @panic("test failure"); + expect(v[31] == 720) catch @panic("test failure"); + expect(v[32] == 721) catch @panic("test failure"); + expect(v[33] == 722) catch @panic("test failure"); + expect(v[34] == 723) catch @panic("test failure"); + expect(v[35] == 724) catch @panic("test failure"); + expect(v[36] == 725) catch @panic("test failure"); + expect(v[37] == 726) catch @panic("test failure"); + expect(v[38] == 727) catch @panic("test failure"); + expect(v[39] == 728) catch @panic("test failure"); + expect(v[40] == 729) catch @panic("test failure"); + expect(v[41] == 730) catch @panic("test failure"); + expect(v[42] == 731) catch @panic("test failure"); + expect(v[43] == 732) catch @panic("test failure"); + expect(v[44] == 733) catch @panic("test failure"); + expect(v[45] == 734) catch @panic("test failure"); + expect(v[46] == 735) catch @panic("test failure"); + expect(v[47] == 736) catch @panic("test failure"); + expect(v[48] == 737) catch @panic("test failure"); + expect(v[49] == 738) catch @panic("test failure"); + expect(v[50] == 739) catch @panic("test failure"); + expect(v[51] == 740) catch @panic("test failure"); + expect(v[52] == 741) catch @panic("test failure"); + expect(v[53] == 742) catch @panic("test failure"); + expect(v[54] == 743) catch @panic("test failure"); + expect(v[55] == 744) catch @panic("test failure"); + expect(v[56] == 745) catch @panic("test failure"); + expect(v[57] == 746) catch @panic("test failure"); + expect(v[58] == 747) catch @panic("test failure"); + expect(v[59] == 748) catch @panic("test failure"); + expect(v[60] == 749) catch @panic("test failure"); + expect(v[61] == 750) catch @panic("test failure"); + expect(v[62] == 751) catch @panic("test failure"); + expect(v[63] == 752) catch @panic("test failure"); + expect(i == 64) catch @panic("test failure"); +} + +extern fn c_ret_vector_64_f64() @Vector(64, f64); +extern fn c_vector_64_f64(@Vector(64, f64), usize) void; +extern fn c_test_vector_64_f64() void; + +test "@Vector(64, f64)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const v = c_ret_vector_64_f64(); + try expect(v[0] == 753); + try expect(v[1] == 754); + try expect(v[2] == 755); + try expect(v[3] == 756); + try expect(v[4] == 757); + try expect(v[5] == 758); + try expect(v[6] == 759); + try expect(v[7] == 760); + try expect(v[8] == 761); + try expect(v[9] == 762); + try expect(v[10] == 763); + try expect(v[11] == 764); + try expect(v[12] == 765); + try expect(v[13] == 766); + try expect(v[14] == 767); + try expect(v[15] == 768); + try expect(v[16] == 769); + try expect(v[17] == 770); + try expect(v[18] == 771); + try expect(v[19] == 772); + try expect(v[20] == 773); + try expect(v[21] == 774); + try expect(v[22] == 775); + try expect(v[23] == 776); + try expect(v[24] == 777); + try expect(v[25] == 778); + try expect(v[26] == 779); + try expect(v[27] == 780); + try expect(v[28] == 781); + try expect(v[29] == 782); + try expect(v[30] == 783); + try expect(v[31] == 784); + try expect(v[32] == 785); + try expect(v[33] == 786); + try expect(v[34] == 787); + try expect(v[35] == 788); + try expect(v[36] == 789); + try expect(v[37] == 790); + try expect(v[38] == 791); + try expect(v[39] == 792); + try expect(v[40] == 793); + try expect(v[41] == 794); + try expect(v[42] == 795); + try expect(v[43] == 796); + try expect(v[44] == 797); + try expect(v[45] == 798); + try expect(v[46] == 799); + try expect(v[47] == 800); + try expect(v[48] == 801); + try expect(v[49] == 802); + try expect(v[50] == 803); + try expect(v[51] == 804); + try expect(v[52] == 805); + try expect(v[53] == 806); + try expect(v[54] == 807); + try expect(v[55] == 808); + try expect(v[56] == 809); + try expect(v[57] == 810); + try expect(v[58] == 811); + try expect(v[59] == 812); + try expect(v[60] == 813); + try expect(v[61] == 814); + try expect(v[62] == 815); + try expect(v[63] == 816); + c_vector_64_f64(.{ + 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, + 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, + 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, + 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, + }, 64); + c_test_vector_64_f64(); +} + +const Struct_u8 = extern struct { + a: u8, +}; + +export fn zig_ret_struct_u8() Struct_u8 { + return .{ .a = 1 }; +} +export fn zig_struct_u8(s: Struct_u8, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_u8() Struct_u8; +extern fn c_struct_u8(Struct_u8, usize) void; +extern fn c_test_struct_u8() void; + +test "struct u8" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_u8(); + try expect(s.a == 4); + c_struct_u8(.{ .a = 5 }, 6); + c_test_struct_u8(); +} + +const Struct_u8_u8 = extern struct { + a: u8, + b: u8, +}; + +export fn zig_ret_struct_u8_u8() Struct_u8_u8 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_u8_u8(s: Struct_u8_u8, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} + +extern fn c_ret_struct_u8_u8() Struct_u8_u8; +extern fn c_struct_u8_u8(Struct_u8_u8, usize) void; +extern fn c_test_struct_u8_u8() void; + +test "struct u8, u8" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u8_u8(); + try expect(s.a == 6); + try expect(s.b == 7); + c_struct_u8_u8(.{ .a = 8, .b = 9 }, 10); + c_test_struct_u8_u8(); +} + +const Struct_u8_u8_u8 = extern struct { + a: u8, + b: u8, + c: u8, +}; + +export fn zig_ret_struct_u8_u8_u8() Struct_u8_u8_u8 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_u8_u8_u8(s: Struct_u8_u8_u8, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_u8_u8_u8() Struct_u8_u8_u8; +extern fn c_struct_u8_u8_u8(Struct_u8_u8_u8, usize) void; +extern fn c_test_struct_u8_u8_u8() void; + +test "struct u8, u8, u8" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u8_u8_u8(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_u8_u8_u8(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_u8_u8_u8(); +} + +const Struct_u8_u8_u8_u8 = extern struct { + a: u8, + b: u8, + c: u8, + d: u8, +}; + +export fn zig_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_u8_u8_u8_u8(s: Struct_u8_u8_u8_u8, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8; +extern fn c_struct_u8_u8_u8_u8(Struct_u8_u8_u8_u8, usize) void; +extern fn c_test_struct_u8_u8_u8_u8() void; + +test "struct u8, u8, u8, u8" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u8_u8_u8_u8(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_u8_u8_u8_u8(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_u8_u8_u8_u8(); +} + +const Struct_u16 = extern struct { + a: u16, +}; + +export fn zig_ret_struct_u16() Struct_u16 { + return .{ .a = 1 }; +} +export fn zig_struct_u16(s: Struct_u16, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_u16() Struct_u16; +extern fn c_struct_u16(Struct_u16, usize) void; +extern fn c_test_struct_u16() void; + +test "struct u16" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_u16(); + try expect(s.a == 4); + c_struct_u16(.{ .a = 5 }, 6); + c_test_struct_u16(); +} + +const Struct_u16_u16 = extern struct { + a: u16, + b: u16, +}; + +export fn zig_ret_struct_u16_u16() Struct_u16_u16 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_u16_u16(s: Struct_u16_u16, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} + +extern fn c_ret_struct_u16_u16() Struct_u16_u16; +extern fn c_struct_u16_u16(Struct_u16_u16, usize) void; +extern fn c_test_struct_u16_u16() void; + +test "struct u16, u16" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u16_u16(); + try expect(s.a == 6); + try expect(s.b == 7); + c_struct_u16_u16(.{ .a = 8, .b = 9 }, 10); + c_test_struct_u16_u16(); +} + +const Struct_u16_u16_u16 = extern struct { + a: u16, + b: u16, + c: u16, +}; + +export fn zig_ret_struct_u16_u16_u16() Struct_u16_u16_u16 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_u16_u16_u16(s: Struct_u16_u16_u16, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_u16_u16_u16() Struct_u16_u16_u16; +extern fn c_struct_u16_u16_u16(Struct_u16_u16_u16, usize) void; +extern fn c_test_struct_u16_u16_u16() void; + +test "struct u16, u16, u16" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u16_u16_u16(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_u16_u16_u16(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_u16_u16_u16(); +} + +const Struct_u16_u16_u16_u16 = extern struct { + a: u16, + b: u16, + c: u16, + d: u16, +}; + +export fn zig_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_u16_u16_u16_u16(s: Struct_u16_u16_u16_u16, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16; +extern fn c_struct_u16_u16_u16_u16(Struct_u16_u16_u16_u16, usize) void; +extern fn c_test_struct_u16_u16_u16_u16() void; + +test "struct u16, u16, u16, u16" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_u16_u16_u16_u16(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_u16_u16_u16_u16(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_u16_u16_u16_u16(); +} + +const Struct_u32 = extern struct { + a: u32, +}; + +export fn zig_ret_struct_u32() Struct_u32 { + return .{ .a = 1 }; +} +export fn zig_struct_u32(s: Struct_u32, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_u32() Struct_u32; +extern fn c_struct_u32(Struct_u32, usize) void; +extern fn c_test_struct_u32() void; + +test "struct u32" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_u32(); + try expect(s.a == 4); + c_struct_u32(.{ .a = 5 }, 6); + c_test_struct_u32(); +} + +const Struct_u32_u32 = extern struct { + a: u32, + b: u32, +}; + +export fn zig_ret_struct_u32_u32() Struct_u32_u32 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_u32_u32(s: Struct_u32_u32, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} + +extern fn c_ret_struct_u32_u32() Struct_u32_u32; +extern fn c_struct_u32_u32(Struct_u32_u32, usize) void; +extern fn c_test_struct_u32_u32() void; + +test "struct u32, u32" { + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_u32_u32(); + try expect(s.a == 6); + try expect(s.b == 7); + c_struct_u32_u32(.{ .a = 8, .b = 9 }, 10); + c_test_struct_u32_u32(); +} + +const Struct_u32_u32_u32 = extern struct { + a: u32, + b: u32, + c: u32, +}; + +export fn zig_ret_struct_u32_u32_u32() Struct_u32_u32_u32 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_u32_u32_u32(s: Struct_u32_u32_u32, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_u32_u32_u32() Struct_u32_u32_u32; +extern fn c_struct_u32_u32_u32(Struct_u32_u32_u32, usize) void; +extern fn c_test_struct_u32_u32_u32() void; + +test "struct u32, u32, u32" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u32_u32_u32(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_u32_u32_u32(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_u32_u32_u32(); +} + +const Struct_u32_u32_u32_u32 = extern struct { + a: u32, + b: u32, + c: u32, + d: u32, +}; + +export fn zig_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_u32_u32_u32_u32(s: Struct_u32_u32_u32_u32, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32; +extern fn c_struct_u32_u32_u32_u32(Struct_u32_u32_u32_u32, usize) void; +extern fn c_test_struct_u32_u32_u32_u32() void; + +test "struct u32, u32, u32, u32" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u32_u32_u32_u32(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_u32_u32_u32_u32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_u32_u32_u32_u32(); +} + +const Struct_u64 = extern struct { + a: u64, +}; + +export fn zig_ret_struct_u64() Struct_u64 { + return .{ .a = 1 }; +} +export fn zig_struct_u64(s: Struct_u64, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_u64() Struct_u64; +extern fn c_struct_u64(Struct_u64, usize) void; +extern fn c_test_struct_u64() void; + +test "struct u64" { + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_u64(); + try expect(s.a == 4); + c_struct_u64(.{ .a = 5 }, 6); + c_test_struct_u64(); +} + +const Struct_u64_u64 = extern struct { + a: u64, + b: u64, +}; + +export fn zig_ret_struct_u64_u64() Struct_u64_u64 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_u64_u64(s: Struct_u64_u64, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 1) catch @panic("test failure"); +} +export fn zig_1_struct_u64_u64(_: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(i == 2) catch @panic("test failure"); +} +export fn zig_2_struct_u64_u64(_: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 7) catch @panic("test failure"); + expect(s.b == 8) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} +export fn zig_3_struct_u64_u64(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 9) catch @panic("test failure"); + expect(s.b == 10) catch @panic("test failure"); + expect(i == 4) catch @panic("test failure"); +} +export fn zig_4_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 11) catch @panic("test failure"); + expect(s.b == 12) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} +export fn zig_5_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 13) catch @panic("test failure"); + expect(s.b == 14) catch @panic("test failure"); + expect(i == 6) catch @panic("test failure"); +} +export fn zig_6_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 15) catch @panic("test failure"); + expect(s.b == 16) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} +export fn zig_7_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 17) catch @panic("test failure"); + expect(s.b == 18) catch @panic("test failure"); + expect(i == 8) catch @panic("test failure"); +} +export fn zig_8_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void { + expect(s.a == 19) catch @panic("test failure"); + expect(s.b == 20) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_u64_u64() Struct_u64_u64; +extern fn c_struct_u64_u64(Struct_u64_u64, usize) void; +extern fn c_1_struct_u64_u64(usize, Struct_u64_u64, usize) void; +extern fn c_2_struct_u64_u64(usize, usize, Struct_u64_u64, usize) void; +extern fn c_3_struct_u64_u64(usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_4_struct_u64_u64(usize, usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_5_struct_u64_u64(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_6_struct_u64_u64(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_7_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_8_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void; +extern fn c_test_struct_u64_u64() void; + +test "struct u64, u64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u64_u64(); + try expect(s.a == 21); + try expect(s.b == 22); + c_struct_u64_u64(.{ .a = 23, .b = 24 }, 1); + c_1_struct_u64_u64(0, .{ .a = 25, .b = 26 }, 2); + c_2_struct_u64_u64(0, 1, .{ .a = 27, .b = 28 }, 3); + c_3_struct_u64_u64(0, 1, 2, .{ .a = 29, .b = 30 }, 4); + c_4_struct_u64_u64(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5); + c_5_struct_u64_u64(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6); + c_6_struct_u64_u64(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7); + c_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8); + c_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9); + c_test_struct_u64_u64(); +} + +const Struct_u64_u64_u64 = extern struct { + a: u64, + b: u64, + c: u64, +}; + +export fn zig_ret_struct_u64_u64_u64() Struct_u64_u64_u64 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_u64_u64_u64(s: Struct_u64_u64_u64, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_u64_u64_u64() Struct_u64_u64_u64; +extern fn c_struct_u64_u64_u64(Struct_u64_u64_u64, usize) void; +extern fn c_test_struct_u64_u64_u64() void; + +test "struct u64, u64, u64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u64_u64_u64(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_u64_u64_u64(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_u64_u64_u64(); +} + +const Struct_u64_u64_u64_u64 = extern struct { + a: u64, + b: u64, + c: u64, + d: u64, +}; + +export fn zig_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_u64_u64_u64_u64(s: Struct_u64_u64_u64_u64, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64; +extern fn c_struct_u64_u64_u64_u64(Struct_u64_u64_u64_u64, usize) void; +extern fn c_test_struct_u64_u64_u64_u64() void; + +test "struct u64, u64, u64, u64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u64_u64_u64_u64(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_u64_u64_u64_u64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_u64_u64_u64_u64(); +} + +const Struct_f32 = extern struct { + a: f32, +}; + +export fn zig_ret_struct_f32() Struct_f32 { + return .{ .a = 1 }; +} +export fn zig_struct_f32(s: Struct_f32, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32() Struct_f32; +extern fn c_struct_f32(Struct_f32, usize) void; +extern fn c_test_struct_f32() void; + +test "struct f32" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_f32(); + try expect(s.a == 4); + c_struct_f32(.{ .a = 5 }, 6); + c_test_struct_f32(); +} + +const Struct_f32_f32 = extern struct { + a: f32, + b: f32, +}; + +export fn zig_ret_struct_f32_f32() Struct_f32_f32 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_f32_f32(s: Struct_f32_f32, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32_f32() Struct_f32_f32; +extern fn c_struct_f32_f32(Struct_f32_f32, usize) void; +extern fn c_test_struct_f32_f32() void; + +test "struct f32, f32" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_f32_f32(); + try expect(s.a == 6); + try expect(s.b == 7); + c_struct_f32_f32(.{ .a = 8, .b = 9 }, 10); + c_test_struct_f32_f32(); +} + +const Struct_f32_f32_f32 = extern struct { + a: f32, + b: f32, + c: f32, +}; + +export fn zig_ret_struct_f32_f32_f32() Struct_f32_f32_f32 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_f32_f32_f32(s: Struct_f32_f32_f32, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32_f32_f32() Struct_f32_f32_f32; +extern fn c_struct_f32_f32_f32(Struct_f32_f32_f32, usize) void; +extern fn c_test_struct_f32_f32_f32() void; + +test "struct f32, f32, f32" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f32_f32_f32(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_f32_f32_f32(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_f32_f32_f32(); +} + +const Struct_f32_f32_f32_f32 = extern struct { + a: f32, + b: f32, + c: f32, + d: f32, +}; + +export fn zig_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32; +extern fn c_struct_f32_f32_f32_f32(Struct_f32_f32_f32_f32, usize) void; +extern fn c_test_struct_f32_f32_f32_f32() void; + +test "struct f32, f32, f32, f32" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f32_f32_f32_f32(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_f32_f32_f32_f32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_f32_f32_f32_f32(); +} + +const Struct_f32_f32_f32_f32_f32 = extern struct { + a: f32, + b: f32, + c: f32, + d: f32, + e: f32, +}; + +export fn zig_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 }; +} +export fn zig_struct_f32_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32_f32, i: usize) void { + expect(s.a == 6) catch @panic("test failure"); + expect(s.b == 7) catch @panic("test failure"); + expect(s.c == 8) catch @panic("test failure"); + expect(s.d == 9) catch @panic("test failure"); + expect(s.e == 10) catch @panic("test failure"); + expect(i == 11) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32; +extern fn c_struct_f32_f32_f32_f32_f32(Struct_f32_f32_f32_f32_f32, usize) void; +extern fn c_test_struct_f32_f32_f32_f32_f32() void; + +test "struct f32, f32, f32, f32, f32" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f32_f32_f32_f32_f32(); + try expect(s.a == 12); + try expect(s.b == 13); + try expect(s.c == 14); + try expect(s.d == 15); + try expect(s.e == 16); + c_struct_f32_f32_f32_f32_f32(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22); + c_test_struct_f32_f32_f32_f32_f32(); +} + +const Struct_f32a8 = extern struct { + a: f32 align(8), +}; + +export fn zig_ret_struct_f32a8() Struct_f32a8 { + return .{ .a = 1.25 }; +} +export fn zig_struct_f32a8(s: Struct_f32a8, f: f32) void { + expect(s.a == 2.75) catch @panic("test failure"); + expect(f == 3.5) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32a8() Struct_f32a8; +extern fn c_struct_f32a8(Struct_f32a8, f32) void; +extern fn c_test_struct_f32a8() void; + +test "struct f32 align(8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_f32a8(); + try expect(s.a == 4.125); + c_struct_f32a8(.{ .a = 5.375 }, 6.5); + c_test_struct_f32a8(); +} + +const Struct_f32a8_f32a8 = extern struct { + a: f32 align(8), + b: f32 align(8), +}; + +export fn zig_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8 { + return .{ .a = 1.25, .b = 2.75 }; +} +export fn zig_struct_f32a8_f32a8(s: Struct_f32a8_f32a8, f: f32) void { + expect(s.a == 3.125) catch @panic("test failure"); + expect(s.b == 4.375) catch @panic("test failure"); + expect(f == 5.5) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8; +extern fn c_struct_f32a8_f32a8(Struct_f32a8_f32a8, f32) void; +extern fn c_test_struct_f32a8_f32a8() void; + +test "struct f32 align(8), f32 align(8)" { + if (builtin.cpu.arch.isArm()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + + const s = c_ret_struct_f32a8_f32a8(); + try expect(s.a == 6.625); + try expect(s.b == 7.875); + c_struct_f32a8_f32a8(.{ .a = 8.0625, .b = 9.1875 }, 10.5); + c_test_struct_f32a8_f32a8(); +} + +const Struct_f32f32_f32 = extern struct { + a: extern struct { b: f32, c: f32 }, + d: f32, +}; + +export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 { + return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 }; +} +export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void { + expect(s.a.b == 1.0) catch @panic("test failure"); + expect(s.a.c == 2.0) catch @panic("test failure"); + expect(s.d == 3.0) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32; +extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void; +extern fn c_test_struct_f32f32_f32() void; + +test "struct {f32, f32}, f32" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f32f32_f32(); + try expect(s.a.b == 1.0); + try expect(s.a.c == 2.0); + try expect(s.d == 3.0); + c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 }); + c_test_struct_f32f32_f32(); +} + +const Struct_f32_f32f32 = extern struct { + a: f32, + b: extern struct { c: f32, d: f32 }, +}; + +export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 { + return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } }; +} +export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void { + expect(s.a == 1.0) catch @panic("test failure"); + expect(s.b.c == 2.0) catch @panic("test failure"); + expect(s.b.d == 3.0) catch @panic("test failure"); +} + +extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32; +extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void; +extern fn c_test_struct_f32_f32f32() void; + +test "struct f32, {f32, f32}" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f32_f32f32(); + try expect(s.a == 1.0); + try expect(s.b.c == 2.0); + try expect(s.b.d == 3.0); + c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } }); + c_test_struct_f32_f32f32(); +} + +const Struct_f64 = extern struct { + a: f64, +}; + +export fn zig_ret_struct_f64() Struct_f64 { + return .{ .a = 1 }; +} +export fn zig_struct_f64(s: Struct_f64, i: usize) void { + expect(s.a == 2) catch @panic("test failure"); + expect(i == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_f64() Struct_f64; +extern fn c_struct_f64(Struct_f64, usize) void; +extern fn c_test_struct_f64() void; + +test "struct f64" { + if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; + + const s = c_ret_struct_f64(); + try expect(s.a == 4); + c_struct_f64(.{ .a = 5 }, 6); + c_test_struct_f64(); +} + +const Struct_f64_f64 = extern struct { + a: f64, + b: f64, +}; + +export fn zig_ret_struct_f64_f64() Struct_f64_f64 { + return .{ .a = 1, .b = 2 }; +} +export fn zig_struct_f64_f64(s: Struct_f64_f64, i: usize) void { + expect(s.a == 3) catch @panic("test failure"); + expect(s.b == 4) catch @panic("test failure"); + expect(i == 5) catch @panic("test failure"); +} + +extern fn c_ret_struct_f64_f64() Struct_f64_f64; +extern fn c_struct_f64_f64(Struct_f64_f64, usize) void; +extern fn c_test_struct_f64_f64() void; + +test "struct f64, f64" { if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest; - if (builtin.cpu.arch.isLoongArch() and builtin.abi.float() == .soft) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f64_f64(); + try expect(s.a == 6); + try expect(s.b == 7); + c_struct_f64_f64(.{ .a = 8, .b = 9 }, 10); + c_test_struct_f64_f64(); +} + +const Struct_f64_f64_f64 = extern struct { + a: f64, + b: f64, + c: f64, +}; + +export fn zig_ret_struct_f64_f64_f64() Struct_f64_f64_f64 { + return .{ .a = 1, .b = 2, .c = 3 }; +} +export fn zig_struct_f64_f64_f64(s: Struct_f64_f64_f64, i: usize) void { + expect(s.a == 4) catch @panic("test failure"); + expect(s.b == 5) catch @panic("test failure"); + expect(s.c == 6) catch @panic("test failure"); + expect(i == 7) catch @panic("test failure"); +} + +extern fn c_ret_struct_f64_f64_f64() Struct_f64_f64_f64; +extern fn c_struct_f64_f64_f64(Struct_f64_f64_f64, usize) void; +extern fn c_test_struct_f64_f64_f64() void; + +test "struct f64, f64, f64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f64_f64_f64(); + try expect(s.a == 8); + try expect(s.b == 9); + try expect(s.c == 10); + c_struct_f64_f64_f64(.{ .a = 11, .b = 12, .c = 13 }, 14); + c_test_struct_f64_f64_f64(); +} + +const Struct_f64_f64_f64_f64 = extern struct { + a: f64, + b: f64, + c: f64, + d: f64, +}; + +export fn zig_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4 }; +} +export fn zig_struct_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64, i: usize) void { + expect(s.a == 5) catch @panic("test failure"); + expect(s.b == 6) catch @panic("test failure"); + expect(s.c == 7) catch @panic("test failure"); + expect(s.d == 8) catch @panic("test failure"); + expect(i == 9) catch @panic("test failure"); +} + +extern fn c_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64; +extern fn c_struct_f64_f64_f64_f64(Struct_f64_f64_f64_f64, usize) void; +extern fn c_test_struct_f64_f64_f64_f64() void; + +test "struct f64, f64, f64, f64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f64_f64_f64_f64(); + try expect(s.a == 10); + try expect(s.b == 11); + try expect(s.c == 12); + try expect(s.d == 13); + c_struct_f64_f64_f64_f64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18); + c_test_struct_f64_f64_f64_f64(); +} + +const Struct_f64_f64_f64_f64_f64 = extern struct { + a: f64, + b: f64, + c: f64, + d: f64, + e: f64, +}; + +export fn zig_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64 { + return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 }; +} +export fn zig_struct_f64_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64_f64, i: usize) void { + expect(s.a == 6) catch @panic("test failure"); + expect(s.b == 7) catch @panic("test failure"); + expect(s.c == 8) catch @panic("test failure"); + expect(s.d == 9) catch @panic("test failure"); + expect(s.e == 10) catch @panic("test failure"); + expect(i == 11) catch @panic("test failure"); +} + +extern fn c_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64; +extern fn c_struct_f64_f64_f64_f64_f64(Struct_f64_f64_f64_f64_f64, usize) void; +extern fn c_test_struct_f64_f64_f64_f64_f64() void; + +test "struct f64, f64, f64, f64, f64" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_f64_f64_f64_f64_f64(); + try expect(s.a == 12); + try expect(s.b == 13); + try expect(s.c == 14); + try expect(s.d == 15); + try expect(s.e == 16); + c_struct_f64_f64_f64_f64_f64(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22); + c_test_struct_f64_f64_f64_f64_f64(); +} + +const Struct_u32_Union_u32_u32u32 = extern struct { + a: u32, + b: extern union { + c: extern struct { + d: u32, + e: u32, + }, + }, +}; + +export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 { + return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } }; +} +export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void { + expect(s.a == 1) catch @panic("test failure"); + expect(s.b.c.d == 2) catch @panic("test failure"); + expect(s.b.c.e == 3) catch @panic("test failure"); +} + +extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32; +extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void; +extern fn c_test_struct_u32_union_u32_u32u32() void; + +test "struct{u32,union{u32,struct{u32,u32}}}" { + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = c_ret_struct_u32_union_u32_u32u32(); + try expect(s.a == 1); + try expect(s.b.c.d == 2); + try expect(s.b.c.e == 3); + c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } }); + c_test_struct_u32_union_u32_u32u32(); +} + +const Struct_i32_i32 = extern struct { + a: i32, + b: i32, +}; +extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32; +extern fn c_struct_i32_i32(Struct_i32_i32) void; + +test "struct i32 i32" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; if (builtin.cpu.arch == .s390x) return error.SkipZigTest; if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest; - c_ptr_size_float_struct(.{ .x = 1, .y = 2 }); + const s: Struct_i32_i32 = .{ + .a = 1, + .b = 2, + }; + const mut_res = c_mut_struct_i32_i32(s); + try expect(s.a == 1); + try expect(s.b == 2); + try expect(mut_res.a == 101); + try expect(mut_res.b == 252); + c_struct_i32_i32(s); +} + +export fn zig_struct_i32_i32(s: Struct_i32_i32) void { + expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1"); + expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2"); +} + +const BigStruct = extern struct { + a: u64, + b: u64, + c: u64, + d: u64, + e: u8, +}; +extern fn c_big_struct(BigStruct) void; + +test "big struct" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = BigStruct{ + .a = 1, + .b = 2, + .c = 3, + .d = 4, + .e = 5, + }; + c_big_struct(s); +} + +export fn zig_big_struct(x: BigStruct) void { + expect(x.a == 1) catch @panic("test failure: zig_big_struct 1"); + expect(x.b == 2) catch @panic("test failure: zig_big_struct 2"); + expect(x.c == 3) catch @panic("test failure: zig_big_struct 3"); + expect(x.d == 4) catch @panic("test failure: zig_big_struct 4"); + expect(x.e == 5) catch @panic("test failure: zig_big_struct 5"); +} + +const BigUnion = extern union { + a: BigStruct, +}; +extern fn c_big_union(BigUnion) void; + +test "big union" { + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const x = BigUnion{ + .a = BigStruct{ + .a = 1, + .b = 2, + .c = 3, + .d = 4, + .e = 5, + }, + }; + c_big_union(x); +} + +export fn zig_big_union(x: BigUnion) void { + expect(x.a.a == 1) catch @panic("test failure: zig_big_union a"); + expect(x.a.b == 2) catch @panic("test failure: zig_big_union b"); + expect(x.a.c == 3) catch @panic("test failure: zig_big_union c"); + expect(x.a.d == 4) catch @panic("test failure: zig_big_union d"); + expect(x.a.e == 5) catch @panic("test failure: zig_big_union e"); +} + +const MedStructMixed = extern struct { + a: u32, + b: f32, + c: f32, + d: u32 = 0, +}; +extern fn c_med_struct_mixed(MedStructMixed) void; +extern fn c_ret_med_struct_mixed() MedStructMixed; + +test "medium struct of ints and floats" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = MedStructMixed{ + .a = 1234, + .b = 100.0, + .c = 1337.0, + }; + c_med_struct_mixed(s); + const s2 = c_ret_med_struct_mixed(); + try expect(s2.a == 1234); + try expect(s2.b == 100.0); + try expect(s2.c == 1337.0); +} + +export fn zig_med_struct_mixed(x: MedStructMixed) void { + expect(x.a == 1234) catch @panic("test failure"); + expect(x.b == 100.0) catch @panic("test failure"); + expect(x.c == 1337.0) catch @panic("test failure"); +} + +const SmallPackedStruct = packed struct(u8) { + a: u2, + b: u2, + c: u2, + d: u2, +}; +extern fn c_small_packed_struct(SmallPackedStruct) void; +extern fn c_ret_small_packed_struct() SmallPackedStruct; + +export fn zig_small_packed_struct(x: SmallPackedStruct) void { + expect(x.a == 0) catch @panic("test failure"); + expect(x.b == 1) catch @panic("test failure"); + expect(x.c == 2) catch @panic("test failure"); + expect(x.d == 3) catch @panic("test failure"); +} + +test "small packed struct" { + const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 }; + c_small_packed_struct(s); + const s2 = c_ret_small_packed_struct(); + try expect(s2.a == 0); + try expect(s2.b == 1); + try expect(s2.c == 2); + try expect(s2.d == 3); +} + +const BigPackedStruct = packed struct(u128) { + a: u64, + b: u64, +}; +extern fn c_big_packed_struct(BigPackedStruct) void; +extern fn c_ret_big_packed_struct() BigPackedStruct; + +export fn zig_big_packed_struct(x: BigPackedStruct) void { + expect(x.a == 1) catch @panic("test failure"); + expect(x.b == 2) catch @panic("test failure"); +} + +test "big packed struct" { + if (!have_i128) return error.SkipZigTest; + + const s = BigPackedStruct{ .a = 1, .b = 2 }; + c_big_packed_struct(s); + const s2 = c_ret_big_packed_struct(); + try expect(s2.a == 1); + try expect(s2.b == 2); +} + +const SplitStructInt = extern struct { + a: u64, + b: u8, + c: u32, +}; +extern fn c_split_struct_ints(SplitStructInt) void; + +test "split struct of ints" { + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = SplitStructInt{ + .a = 1234, + .b = 100, + .c = 1337, + }; + c_split_struct_ints(s); +} + +export fn zig_split_struct_ints(x: SplitStructInt) void { + expect(x.a == 1234) catch @panic("test failure"); + expect(x.b == 100) catch @panic("test failure"); + expect(x.c == 1337) catch @panic("test failure"); +} + +const SplitStructMixed = extern struct { + a: u64, + b: u8, + c: f32, +}; +extern fn c_split_struct_mixed(SplitStructMixed) void; +extern fn c_ret_split_struct_mixed() SplitStructMixed; + +test "split struct of ints and floats" { + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = SplitStructMixed{ + .a = 1234, + .b = 100, + .c = 1337.0, + }; + c_split_struct_mixed(s); + const s2 = c_ret_split_struct_mixed(); + try expect(s2.a == 1234); + try expect(s2.b == 100); + try expect(s2.c == 1337.0); +} + +export fn zig_split_struct_mixed(x: SplitStructMixed) void { + expect(x.a == 1234) catch @panic("test failure"); + expect(x.b == 100) catch @panic("test failure"); + expect(x.c == 1337.0) catch @panic("test failure"); +} + +extern fn c_big_struct_both(BigStruct) BigStruct; + +test "sret and byval together" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + const s = BigStruct{ + .a = 1, + .b = 2, + .c = 3, + .d = 4, + .e = 5, + }; + const y = c_big_struct_both(s); + try expect(y.a == 10); + try expect(y.b == 11); + try expect(y.c == 12); + try expect(y.d == 13); + try expect(y.e == 14); +} + +export fn zig_big_struct_both(x: BigStruct) BigStruct { + expect(x.a == 30) catch @panic("test failure"); + expect(x.b == 31) catch @panic("test failure"); + expect(x.c == 32) catch @panic("test failure"); + expect(x.d == 33) catch @panic("test failure"); + expect(x.e == 34) catch @panic("test failure"); + const s = BigStruct{ + .a = 20, + .b = 21, + .c = 22, + .d = 23, + .e = 24, + }; + return s; +} + +export fn zig_ret_bool() bool { + return true; +} +export fn zig_ret_u8() u8 { + return 0xff; +} +export fn zig_ret_u16() u16 { + return 0xffff; +} +export fn zig_ret_u32() u32 { + return 0xffffffff; +} +export fn zig_ret_u64() u64 { + return 0xffffffffffffffff; +} +export fn zig_ret_i8() i8 { + return -1; +} +export fn zig_ret_i16() i16 { + return -1; +} +export fn zig_ret_i32() i32 { + return -1; +} +export fn zig_ret_i64() i64 { + return -1; +} + +export fn zig_ret_med_struct_mixed() MedStructMixed { + return .{ + .a = 1234, + .b = 100.0, + .c = 1337.0, + }; +} + +export fn zig_ret_split_struct_mixed() SplitStructMixed { + return .{ + .a = 1234, + .b = 100, + .c = 1337.0, + }; +} + +extern fn c_ret_bool() bool; +extern fn c_ret_u8() u8; +extern fn c_ret_u16() u16; +extern fn c_ret_u32() u32; +extern fn c_ret_u64() u64; +extern fn c_ret_i8() i8; +extern fn c_ret_i16() i16; +extern fn c_ret_i32() i32; +extern fn c_ret_i64() i64; + +test "integer return types" { + try expect(c_ret_bool() == true); + + try expect(c_ret_u8() == 0xff); + try expect(c_ret_u16() == 0xffff); + try expect(c_ret_u32() == 0xffffffff); + try expect(c_ret_u64() == 0xffffffffffffffff); + + try expect(c_ret_i8() == -1); + try expect(c_ret_i16() == -1); + try expect(c_ret_i32() == -1); + try expect(c_ret_i64() == -1); +} + +const StructWithArray = extern struct { + a: i32, + padding: [4]u8, + b: i64, +}; +extern fn c_struct_with_array(StructWithArray) void; +extern fn c_ret_struct_with_array() StructWithArray; + +test "Struct with array as padding." { + if (builtin.cpu.arch == .x86) return error.SkipZigTest; + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 }); + + const x = c_ret_struct_with_array(); + try expect(x.a == 4); + try expect(x.b == 155); +} + +const FloatArrayStruct = extern struct { + origin: extern struct { + x: f64, + y: f64, + }, + size: extern struct { + width: f64, + height: f64, + }, +}; + +extern fn c_float_array_struct(FloatArrayStruct) void; +extern fn c_ret_float_array_struct() FloatArrayStruct; + +test "Float array like struct" { + if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; + if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest; + if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest; + if (builtin.cpu.arch == .hexagon) return error.SkipZigTest; + if (builtin.cpu.arch == .s390x) return error.SkipZigTest; + + c_float_array_struct(.{ + .origin = .{ + .x = 5, + .y = 6, + }, + .size = .{ + .width = 7, + .height = 8, + }, + }); - const x = c_ret_ptr_size_float_struct(); - try expect(x.x == 3); - try expect(x.y == 4); + const x = c_ret_float_array_struct(); + try expect(x.origin.x == 1); + try expect(x.origin.y == 2); + try expect(x.size.width == 3); + try expect(x.size.height == 4); } //=== Helpers for struct test ===// diff --git a/test/tests.zig b/test/tests.zig index 4d0e9cdc8dae3baacae4591d16efa4c7552a6481..c61f452e53865f17def686de3b3acc39a21a15fb 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -2018,12 +2018,43 @@ const c_abi_targets = blk: { .abi = .gnu, }, }, + + //.{ + // .target = .{ + // .cpu_arch = .x86_64, + // .os_tag = .windows, + // .abi = .gnu, + // }, + // .use_llvm = false, + // .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"}, + //}, + //.{ + // .target = .{ + // .cpu_arch = .x86_64, + // .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v2 }, + // .os_tag = .windows, + // .abi = .gnu, + // }, + // .use_llvm = false, + // .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"}, + //}, + //.{ + // .target = .{ + // .cpu_arch = .x86_64, + // .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v3 }, + // .os_tag = .windows, + // .abi = .gnu, + // }, + // .use_llvm = false, + // .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"}, + //}, .{ .target = .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu, }, + .use_llvm = true, }, }; }; -- 2.54.0 From 2e7bd58abaafae8a029bc1a372085ace6738a365 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 19 Jun 2026 19:31:25 -0400 Subject: [PATCH 3/4] x86_64: fix incorrect lowering of win64 varargs --- src/codegen/x86_64/CodeGen.zig | 1050 ++++++++++++++++---------------- src/codegen/x86_64/abi.zig | 28 +- test/c_abi/cfuncs.c | 15 + test/c_abi/main.zig | 39 +- 4 files changed, 606 insertions(+), 526 deletions(-) diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig index 8d8b22da7bd1b79fa24e53a39963b69d188fa07e..85f02b32ccf7dbb7c26f2ef7f59afc78a60f7e46 100644 --- a/src/codegen/x86_64/CodeGen.zig +++ b/src/codegen/x86_64/CodeGen.zig @@ -211,10 +211,10 @@ pub const MCValue = union(enum) { /// The value is in memory at a constant offset from the address in a register. indirect: bits.RegisterOffset, indirect_load_frame: bits.FrameAddr, - /// The value stored at an offset from a frame index + /// The value stored at an offset from a frame index. /// Payload is a frame address. load_frame: bits.FrameAddr, - /// The address of an offset from a frame index + /// The address of an offset from a frame index. /// Payload is a frame address. lea_frame: bits.FrameAddr, load_nav: InternPool.Nav.Index, @@ -225,15 +225,17 @@ pub const MCValue = union(enum) { lea_lazy_sym: link.File.LazySymbol, load_extern_func: Mir.NullTerminatedString, lea_extern_func: Mir.NullTerminatedString, - /// Supports `integer_per_element` abi + /// The value is duplicated in two different registers. + register_tee: [4]Register, + /// Supports `integer_per_element` abi. elementwise_gpr: ArgsInfo, - /// Supports `sse_per_element` abi + /// Supports `sse_per_element` abi. elementwise_sse: ArgsInfo, - /// Supports `sse_per_xword` abi + /// Supports `sse_per_xword` abi. xwordwise_sse: ArgsInfo, - /// Supports `sse_per_yword` abi + /// Supports `sse_per_yword` abi. ywordwise_sse: ArgsInfo, - /// Supports `sse_per_zword` abi + /// Supports `sse_per_zword` abi. zwordwise_sse: ArgsInfo, /// This indicates that we have already allocated a frame index for this instruction, /// but it has not been spilled there yet in the current control flow. @@ -261,6 +263,7 @@ pub const MCValue = union(enum) { .lea_lazy_sym, .lea_extern_func, .load_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -386,6 +389,7 @@ pub const MCValue = union(enum) { .lea_uav, .lea_lazy_sym, .lea_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -427,6 +431,7 @@ pub const MCValue = union(enum) { .load_uav, .load_lazy_sym, .load_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -453,6 +458,7 @@ pub const MCValue = union(enum) { .unreach, .dead, .undef, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -511,6 +517,7 @@ pub const MCValue = union(enum) { .register_mask, .indirect_load_frame, .lea_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -593,6 +600,7 @@ pub const MCValue = union(enum) { .lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }), .load_extern_func => |pl| try w.print("[extern:{d}]", .{@intFromEnum(pl)}), .lea_extern_func => |pl| try w.print("extern:{d}", .{@intFromEnum(pl)}), + .register_tee => |pl| try w.print("tee:{s}:{s}", .{ @tagName(pl[1]), @tagName(pl[0]) }), .elementwise_gpr => |pl| try w.print("elementwise:gpr{d}:[{f} + 0x{x}]", .{ pl.info.reg_index, pl.frame_index, pl.info.frame_off, }), @@ -640,6 +648,7 @@ const InstTracking = struct { .lea_extern_func, => result, .dead, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -756,6 +765,7 @@ const InstTracking = struct { .register_overflow, .register_mask, .indirect, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -174266,15 +174276,16 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co const ExpectedContents = [@typeInfo(RegisterManager.TrackedRegisters).array.len]RegisterLock; const bfa_buf_len = if (opts.update_tracking) 0 else 1; var bfa_buf: [bfa_buf_len]ExpectedContents = undefined; - var stack = if (opts.update_tracking) {} else std.heap.BufferFirstAllocator.init(@ptrCast(&bfa_buf), self.gpa); + var stack = if (!opts.update_tracking) std.heap.BufferFirstAllocator.init(@ptrCast(&bfa_buf), self.gpa); + const allocator = if (!opts.update_tracking) stack.allocator(); - var reg_locks = if (opts.update_tracking) {} else try std.array_list.Managed(RegisterLock).initCapacity( - stack.allocator(), + var reg_locks = if (!opts.update_tracking) try std.ArrayList(RegisterLock).initCapacity( + allocator, @typeInfo(ExpectedContents).array.len, ); defer if (!opts.update_tracking) { for (reg_locks.items) |lock| self.register_manager.unlockReg(lock); - reg_locks.deinit(); + reg_locks.deinit(allocator); }; for ( @@ -174304,7 +174315,7 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co self.inst_tracking.getPtr(target_inst).?.trackMaterialize(target_inst, reg_tracking); } } else if (target_maybe_inst) |_| - try reg_locks.append(self.register_manager.lockRegIndexAssumeUnused(reg_index)); + try reg_locks.append(allocator, self.register_manager.lockRegIndexAssumeUnused(reg_index)); } if (opts.emit_instructions) if (self.eflags_inst) |inst| try self.inst_tracking.getPtr(inst).?.spill(self, inst); @@ -174517,6 +174528,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -174574,6 +174586,7 @@ fn store( .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -174628,6 +174641,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: .lea_uav, .lea_lazy_sym, .lea_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -175322,6 +175336,7 @@ fn genBinOpMir( .lea_lazy_sym, .lea_extern_func, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -175363,6 +175378,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -175539,6 +175555,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -175647,6 +175664,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -176002,6 +176020,7 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue .none, .unreach, .dead, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -176060,6 +176079,7 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue .none, .unreach, .dead, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -176197,14 +176217,14 @@ fn genCall(cg: *CodeGen, info: union(enum) { const var_args = try allocator.alloc(Type, args.len - fn_info.param_types.len); defer allocator.free(var_args); - for (var_args, arg_types[fn_info.param_types.len..]) |*var_arg, arg_ty| var_arg.* = arg_ty; + @memcpy(var_args, arg_types[fn_info.param_types.len..]); const frame_indices = try allocator.alloc(FrameIndex, args.len); defer allocator.free(frame_indices); - var reg_locks: std.array_list.Managed(?RegisterLock) = .init(allocator); - defer reg_locks.deinit(); - try reg_locks.ensureTotalCapacity(16); + var reg_locks: std.ArrayList(?RegisterLock) = .empty; + defer reg_locks.deinit(allocator); + try reg_locks.ensureTotalCapacity(allocator, 16); defer for (reg_locks.items) |reg_lock| if (reg_lock) |lock| cg.register_manager.unlockReg(lock); var call_info = try cg.resolveCallingConventionValues(fn_info, var_args, .call_frame); @@ -176235,169 +176255,165 @@ fn genCall(cg: *CodeGen, info: union(enum) { .indirect => |reg_off| try cg.register_manager.getReg(reg_off.reg, null), else => unreachable, } - for (call_info.args, arg_types, args, frame_indices, 0..) |dst_arg, arg_ty, src_arg, *frame_index, arg_i| - switch (dst_arg) { - .none => {}, - .register => |reg| { + for (call_info.args, arg_types, args, frame_indices) |dst_arg, arg_ty, src_arg, *frame_index| switch (dst_arg) { + .none => {}, + .register => |reg| { + try cg.register_manager.getReg(reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(reg)); + }, + inline .register_pair, .register_triple, .register_quadruple => |regs| { + for (regs) |reg| try cg.register_manager.getReg(reg, null); + try reg_locks.appendSlice(allocator, &cg.register_manager.lockRegs(regs.len, regs)); + }, + .indirect => |reg_off| { + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + try cg.register_manager.getReg(reg_off.reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(reg_off.reg)); + }, + .indirect_load_frame => |frame_addr| { + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + try cg.genSetMem( + .{ .frame = frame_addr.index }, + frame_addr.off, + .usize, + .{ .lea_frame = .{ .index = frame_index.* } }, + opts, + ); + }, + .load_frame => { + try cg.genCopy(arg_ty, dst_arg, src_arg, opts); + try cg.freeValue(src_arg, .{}); + }, + .register_tee => |regs| { + try reg_locks.ensureUnusedCapacity(allocator, regs.len); + for (regs) |reg| if (reg != .none) { try cg.register_manager.getReg(reg, null); - try reg_locks.append(cg.register_manager.lockReg(reg)); + reg_locks.appendAssumeCapacity(cg.register_manager.lockReg(reg)); + }; + }, + .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { + const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ + .base = .{ .reg = try cg.copyToTmpRegister(.usize, switch (src_arg) { + else => src_arg, + .air_ref => |src_ref| try cg.resolveInst(src_ref), + }.address()) }, + .mod = .{ .rm = .{ .size = .dword } }, + }; + const src_lock = switch (src_mem.base) { + .reg => |src_reg| cg.register_manager.lockReg(src_reg), + else => null, + }; + defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); - if (fn_info.is_var_args and - fn_info.cc == .x86_64_win and - reg.class() == .sse and - arg_i < abi.Win64.c_abi_int_param_regs.len) - { - // Floating point arguments must be duplicated into the equivalent integer registers on this ABI - const int_reg = abi.Win64.c_abi_int_param_regs[arg_i]; - try reg_locks.append(cg.register_manager.lockReg(int_reg)); - } - }, - .register_pair => |regs| { - for (regs) |reg| try cg.register_manager.getReg(reg, null); - try reg_locks.appendSlice(&cg.register_manager.lockRegs(2, regs)); - }, - .indirect => |reg_off| { - frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); - try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); - try cg.register_manager.getReg(reg_off.reg, null); - try reg_locks.append(cg.register_manager.lockReg(reg_off.reg)); - }, - .indirect_load_frame => |frame_addr| { - frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); - try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); - try cg.genSetMem( - .{ .frame = frame_addr.index }, - frame_addr.off, - .usize, - .{ .lea_frame = .{ .index = frame_index.* } }, - opts, - ); - }, - .load_frame => { - try cg.genCopy(arg_ty, dst_arg, src_arg, opts); - try cg.freeValue(src_arg, .{}); - }, - .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { - const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ - .base = .{ .reg = try cg.copyToTmpRegister(.usize, switch (src_arg) { - else => src_arg, - .air_ref => |src_ref| try cg.resolveInst(src_ref), - }.address()) }, - .mod = .{ .rm = .{ .size = .dword } }, - }; - const src_lock = switch (src_mem.base) { - .reg => |src_reg| cg.register_manager.lockReg(src_reg), - else => null, - }; - defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); - - const elem_rc: Register.Class, const param_regs = switch (dst_arg) { - else => unreachable, - .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, - .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, - }; - const len = arg_ty.vectorLen(zcu); - const param_reg_len: u31 = - @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); + const elem_rc: Register.Class, const param_regs = switch (dst_arg) { + else => unreachable, + .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, + .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, + }; + const len = arg_ty.vectorLen(zcu); + const param_reg_len: u31 = + @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); - if (len - param_reg_len > 0) { - const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); - const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg); - defer cg.register_manager.unlockReg(index_lock); - try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len)); + if (len - param_reg_len > 0) { + const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); + const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg); + defer cg.register_manager.unlockReg(index_lock); + try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len)); - const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len); - const elem_ty = arg_ty.childType(zcu); - if (elem_ty.toIntern() == .bool_type) { - try cg.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32()); - try cg.asmSetccMemory(.c, .{ - .base = .{ .frame = regs_frame_addr.frame_index }, - .mod = .{ .rm = .{ - .size = .byte, - .index = index_reg.to64(), - .scale = .@"8", - .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, - } }, - }); - } else { - const elem_reg = - try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc)); - const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg); - defer cg.register_manager.unlockReg(elem_lock); - const elem_size = cg.memSize(elem_ty, .general_purpose); - const elem_alias = elem_reg.toSize(elem_size, cg.target); + const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len); + const elem_ty = arg_ty.childType(zcu); + if (elem_ty.toIntern() == .bool_type) { + try cg.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32()); + try cg.asmSetccMemory(.c, .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = .byte, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }); + } else { + const elem_reg = + try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc)); + const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg); + defer cg.register_manager.unlockReg(elem_lock); + const elem_size = cg.memSize(elem_ty, .general_purpose); + const elem_alias = elem_reg.toSize(elem_size, cg.target); - const strat = try cg.moveStrategy(elem_ty, elem_rc, true); - assert(src_mem.mod.rm.index == .none and src_mem.mod.rm.scale == .@"1"); - try strat.read(cg, elem_alias, .{ - .base = src_mem.base, - .mod = .{ .rm = .{ - .size = elem_size, - .index = index_reg.to64(), - .scale = .fromFactor(@intCast(@divExact(elem_size.bitSize(cg.target), 8))), - .disp = src_mem.mod.rm.disp, - } }, - }); - try strat.write(cg, .{ - .base = .{ .frame = regs_frame_addr.frame_index }, - .mod = .{ .rm = .{ - .size = elem_size, - .index = index_reg.to64(), - .scale = .@"8", - .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, - } }, - }, elem_alias); - } - if (cg.hasFeature(.slow_incdec)) { - try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); - } else { - try cg.asmRegister(.{ ._c, .in }, index_reg.to32()); - } - try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len)); - _ = try cg.asmJccReloc(.b, loop); + const strat = try cg.moveStrategy(elem_ty, elem_rc, true); + assert(src_mem.mod.rm.index == .none and src_mem.mod.rm.scale == .@"1"); + try strat.read(cg, elem_alias, .{ + .base = src_mem.base, + .mod = .{ .rm = .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .fromFactor(@intCast(@divExact(elem_size.bitSize(cg.target), 8))), + .disp = src_mem.mod.rm.disp, + } }, + }); + try strat.write(cg, .{ + .base = .{ .frame = regs_frame_addr.frame_index }, + .mod = .{ .rm = .{ + .size = elem_size, + .index = index_reg.to64(), + .scale = .@"8", + .disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len, + } }, + }, elem_alias); } - - for (param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len]) |dst_reg| { - try cg.register_manager.getReg(dst_reg, null); - try reg_locks.append(cg.register_manager.lockReg(dst_reg)); + if (cg.hasFeature(.slow_incdec)) { + try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1)); + } else { + try cg.asmRegister(.{ ._c, .in }, index_reg.to32()); } - }, - .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { - const elem_size: u31 = switch (dst_arg) { - else => unreachable, - .xwordwise_sse => 16, - .ywordwise_sse => 32, - .zwordwise_sse => 64, - }; - const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); - const arg_size: u31 = @intCast(arg_ty.abiSize(zcu)); - const len = @divExact(arg_size, elem_size); - const param_gpr_len: u31 = - @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); + try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len)); + _ = try cg.asmJccReloc(.b, loop); + } - frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); - try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); + for (param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len]) |dst_reg| { + try cg.register_manager.getReg(dst_reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(dst_reg)); + } + }, + .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { + const elem_size: u31 = switch (dst_arg) { + else => unreachable, + .xwordwise_sse => 16, + .ywordwise_sse => 32, + .zwordwise_sse => 64, + }; + const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const arg_size: u31 = @intCast(arg_ty.abiSize(zcu)); + const len = @divExact(arg_size, elem_size); + const param_gpr_len: u31 = + @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); - var frame_offset: i32 = regs_frame_addr.info.frame_off; - var arg_offset = elem_size * param_gpr_len; - while (arg_size - arg_offset != 0) : ({ - frame_offset += 8; - arg_offset += elem_size; - }) try cg.genSetMem( - .{ .frame = regs_frame_addr.frame_index }, - frame_offset, - .usize, - .{ .lea_frame = .{ .index = frame_index.*, .off = arg_offset } }, - opts, - ); + frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); + try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); - for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { - try cg.register_manager.getReg(dst_reg, null); - try reg_locks.append(cg.register_manager.lockReg(dst_reg)); - } - }, - else => unreachable, - }; + var frame_offset: i32 = regs_frame_addr.info.frame_off; + var arg_offset = elem_size * param_gpr_len; + while (arg_size - arg_offset != 0) : ({ + frame_offset += 8; + arg_offset += elem_size; + }) try cg.genSetMem( + .{ .frame = regs_frame_addr.frame_index }, + frame_offset, + .usize, + .{ .lea_frame = .{ .index = frame_index.*, .off = arg_offset } }, + opts, + ); + + for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { + try cg.register_manager.getReg(dst_reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(dst_reg)); + } + }, + else => unreachable, + }; if (call_info.err_ret_trace_reg != .none) { if (cg.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { @@ -176406,7 +176422,7 @@ fn genCall(cg: *CodeGen, info: union(enum) { else => true, }) { try cg.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index); - try reg_locks.append(cg.register_manager.lockReg(call_info.err_ret_trace_reg)); + try reg_locks.append(allocator, cg.register_manager.lockReg(call_info.err_ret_trace_reg)); try cg.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, opts); err_ret_trace.trackMaterialize(err_ret_trace_index, .{ @@ -176427,114 +176443,102 @@ fn genCall(cg: *CodeGen, info: union(enum) { .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, }, opts); call_info.return_value.short = .{ .load_frame = .{ .index = frame_index } }; - try reg_locks.append(cg.register_manager.lockReg(reg_off.reg)); + try reg_locks.append(allocator, cg.register_manager.lockReg(reg_off.reg)); }, else => unreachable, } - for (call_info.args, arg_types, args, frame_indices, 0..) |dst_arg, arg_ty, src_arg, frame_index, arg_i| - switch (dst_arg) { - .none, .load_frame, .indirect_load_frame => {}, - .register => |dst_reg| switch (fn_info.cc) { - else => try cg.genSetReg(registerAlias( + for (call_info.args, arg_types, args, frame_indices) |dst_arg, arg_ty, src_arg, frame_index| switch (dst_arg) { + .none, .load_frame, .indirect_load_frame => {}, + .register => |dst_reg| try cg.genSetReg(registerAlias( + dst_reg, + @intCast(cg.unalignedSize(arg_ty)), + ), arg_ty, src_arg, opts), + .register_pair, + .register_triple, + .register_quadruple, + => try cg.genCopy(arg_ty, dst_arg, src_arg, opts), + .indirect => |reg_off| try cg.genSetReg(reg_off.reg, .usize, .{ + .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, + }, opts), + .register_tee => |dst_regs| { + try cg.genSetReg(dst_regs[0], arg_ty, src_arg, opts); + for (dst_regs[1..]) |dst_reg| if (dst_reg != .none) try cg.genSetReg(dst_reg, arg_ty, .{ + .register = dst_regs[0], + }, opts); + }, + .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { + const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ + .base = .{ .reg = try cg.copyToTmpRegister( + .usize, + switch (src_arg) { + else => src_arg, + .air_ref => |src_ref| try cg.resolveInst(src_ref), + }.address(), + ) }, + .mod = .{ .rm = .{ .size = .dword } }, + }; + const src_lock = switch (src_mem.base) { + .reg => |src_reg| cg.register_manager.lockReg(src_reg), + else => null, + }; + defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); + + const elem_rc: Register.Class, const param_regs = switch (dst_arg) { + else => unreachable, + .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, + .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, + }; + const len = arg_ty.vectorLen(zcu); + const elem_ty = arg_ty.childType(zcu); + const elem_size = cg.memSize(elem_ty, .general_purpose); + const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8); + const param_reg_len: u31 = + @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); + const strat = if (elem_ty.toIntern() == .bool_type) strat: { + try cg.spillEflagsIfOccupied(); + break :strat undefined; + } else try cg.moveStrategy(elem_ty, elem_rc, true); + for ( + param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len], + 0.., + ) |dst_reg, elem_index| if (elem_ty.toIntern() == .bool_type) { + try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); + try cg.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index)); + try cg.asmSetccRegister(.c, dst_reg.to8()); + } else try strat.read(cg, dst_reg.toSize(elem_size, cg.target), .{ + .base = src_mem.base, + .mod = .{ .rm = .{ + .size = elem_size, + .disp = src_mem.mod.rm.disp + @as(u31, @intCast(elem_abi_size * elem_index)), + } }, + }); + }, + .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { + const elem_size: u31 = switch (dst_arg) { + else => unreachable, + .xwordwise_sse => 16, + .ywordwise_sse => 32, + .zwordwise_sse => 64, + }; + const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); + const len = @divExact(arg_ty.abiSize(zcu), elem_size); + const param_gpr_len: u31 = + @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); + + var arg_offset: u31 = 0; + for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { + try cg.genSetReg( dst_reg, - @intCast(arg_ty.abiSize(zcu)), - ), arg_ty, src_arg, opts), - .x86_64_sysv, .x86_64_win => { - const promoted_ty = cg.promoteInt(arg_ty); - const promoted_unaligned_size: u32 = @intCast(cg.unalignedSize(promoted_ty)); - const dst_alias = registerAlias(dst_reg, promoted_unaligned_size); - try cg.genSetReg(dst_alias, promoted_ty, src_arg, opts); - if (promoted_ty.toIntern() != arg_ty.toIntern()) - try cg.truncateRegister(arg_ty, dst_alias); - - if (fn_info.is_var_args and - fn_info.cc == .x86_64_win and - dst_reg.class() == .sse and - arg_i < abi.Win64.c_abi_int_param_regs.len) - { - const int_dst_reg = abi.Win64.c_abi_int_param_regs[arg_i]; - const int_dst_alias = registerAlias(int_dst_reg, promoted_unaligned_size); - try cg.genSetReg(int_dst_alias, promoted_ty, .{ .register = dst_alias }, opts); - } - }, - }, - .register_pair => try cg.genCopy(arg_ty, dst_arg, src_arg, opts), - .indirect => |reg_off| try cg.genSetReg(reg_off.reg, .usize, .{ - .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, - }, opts), - .elementwise_gpr, .elementwise_sse => |regs_frame_addr| { - const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{ - .base = .{ .reg = try cg.copyToTmpRegister( - .usize, - switch (src_arg) { - else => src_arg, - .air_ref => |src_ref| try cg.resolveInst(src_ref), - }.address(), - ) }, - .mod = .{ .rm = .{ .size = .dword } }, - }; - const src_lock = switch (src_mem.base) { - .reg => |src_reg| cg.register_manager.lockReg(src_reg), - else => null, - }; - defer if (src_lock) |lock| cg.register_manager.unlockReg(lock); - - const elem_rc: Register.Class, const param_regs = switch (dst_arg) { - else => unreachable, - .elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) }, - .elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) }, - }; - const len = arg_ty.vectorLen(zcu); - const elem_ty = arg_ty.childType(zcu); - const elem_size = cg.memSize(elem_ty, .general_purpose); - const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8); - const param_reg_len: u31 = - @intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len)); - const strat = if (elem_ty.toIntern() == .bool_type) strat: { - try cg.spillEflagsIfOccupied(); - break :strat undefined; - } else try cg.moveStrategy(elem_ty, elem_rc, true); - for ( - param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len], - 0.., - ) |dst_reg, elem_index| if (elem_ty.toIntern() == .bool_type) { - try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32()); - try cg.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index)); - try cg.asmSetccRegister(.c, dst_reg.to8()); - } else try strat.read(cg, dst_reg.toSize(elem_size, cg.target), .{ - .base = src_mem.base, - .mod = .{ .rm = .{ - .size = elem_size, - .disp = src_mem.mod.rm.disp + @as(u31, @intCast(elem_abi_size * elem_index)), - } }, - }); - }, - .xwordwise_sse, .ywordwise_sse, .zwordwise_sse => |regs_frame_addr| { - const elem_size: u31 = switch (dst_arg) { - else => unreachable, - .xwordwise_sse => 16, - .ywordwise_sse => 32, - .zwordwise_sse => 64, - }; - const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc); - const len = @divExact(arg_ty.abiSize(zcu), elem_size); - const param_gpr_len: u31 = - @intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len)); - - var arg_offset: u31 = 0; - for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) |dst_reg| { - try cg.genSetReg( - dst_reg, - .usize, - .{ .lea_frame = .{ .index = frame_index, .off = arg_offset } }, - opts, - ); - arg_offset += elem_size; - } - }, - else => unreachable, - }; + .usize, + .{ .lea_frame = .{ .index = frame_index, .off = arg_offset } }, + opts, + ); + arg_offset += elem_size; + } + }, + else => unreachable, + }; if (fn_info.is_var_args and fn_info.cc == .x86_64_sysv) try cg.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count)); @@ -177474,13 +177478,13 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { const inputs = unwrapped_asm.inputs; var result: MCValue = .none; - var args: std.array_list.Managed(MCValue) = .init(self.gpa); - try args.ensureTotalCapacity(outputs.len + inputs.len); + var args = try self.gpa.alloc(MCValue, outputs.len + inputs.len); + var args_len: usize = 0; defer { - for (args.items) |arg| if (arg.getReg()) |reg| self.register_manager.unlockReg(.{ + for (args[0..args_len]) |arg| if (arg.getReg()) |reg| self.register_manager.unlockReg(.{ .tracked_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue, }); - args.deinit(); + self.gpa.free(args); } var arg_map: std.StringHashMap(u8) = .init(self.gpa); try arg_map.ensureTotalCapacity(@intCast(outputs.len + inputs.len)); @@ -177539,10 +177543,10 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { return self.fail("invalid register constraint: '{s}'", .{out.constraint}) else if (rest.len == 1 and std.ascii.isDigit(rest[0])) { const index = std.fmt.charToDigit(rest[0], 10) catch unreachable; - if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{ + if (index >= args_len) return self.fail("constraint out of bounds: '{s}'", .{ out.constraint, }); - break :arg_mcv args.items[index]; + break :arg_mcv args[index]; } else return self.fail("invalid constraint: '{s}'", .{out.constraint}); break :arg_mcv if (arg_maybe_reg) |reg| .{ .register = reg } else arg: { const ptr_mcv = try self.resolveInst(out.operand); @@ -177560,8 +177564,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { _ = self.register_manager.lockRegIndexAssumeUnused(tracked_index); }; if (!std.mem.eql(u8, out.name, "_")) - arg_map.putAssumeCapacityNoClobber(out.name, @intCast(args.items.len)); - args.appendAssumeCapacity(arg_mcv); + arg_map.putAssumeCapacityNoClobber(out.name, @intCast(args_len)); + args[args_len] = arg_mcv; + args_len += 1; if (out.operand == .none) result = arg_mcv; if (is_read) try self.load(arg_mcv, self.typeOf(out.operand), .{ .air_ref = out.operand }); } @@ -177644,17 +177649,19 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { break :arg .{ .register = reg }; } else if (in.constraint.len == 1 and std.ascii.isDigit(in.constraint[0])) arg: { const index = std.fmt.charToDigit(in.constraint[0], 10) catch unreachable; - if (index >= args.items.len) return self.fail("constraint out of bounds: '{s}'", .{in.constraint}); - try self.genCopy(ty, args.items[index], input_mcv, .{}); - break :arg args.items[index]; + if (index >= args_len) return self.fail("constraint out of bounds: '{s}'", .{in.constraint}); + try self.genCopy(ty, args[index], input_mcv, .{}); + break :arg args[index]; } else return self.fail("invalid constraint: '{s}'", .{in.constraint}); if (arg_mcv.getReg()) |reg| if (RegisterManager.indexOfRegIntoTracked(reg)) |_| { _ = self.register_manager.lockReg(reg); }; if (!std.mem.eql(u8, in.name, "_")) - arg_map.putAssumeCapacityNoClobber(in.name, @intCast(args.items.len)); - args.appendAssumeCapacity(arg_mcv); + arg_map.putAssumeCapacityNoClobber(in.name, @intCast(args_len)); + args[args_len] = arg_mcv; + args_len += 1; } + assert(args_len == args.len); const ip = &zcu.intern_pool; const clobbers_val: Value = .fromInterned(unwrapped_asm.clobbers); @@ -177887,7 +177894,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { op_str[colon_pos + ":".len .. op_str.len - "]".len] else ""; - op.* = switch (args.items[ + op.* = switch (args[ arg_map.get(op_str["%[".len .. colon orelse op_str.len - "]".len]) orelse return self.fail("no matching constraint: '{s}'", .{op_str}) ]) { @@ -178031,7 +178038,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { op_str[colon_pos + ":".len .. open - "]".len] else ""; - break :disp switch (args.items[ + break :disp switch (args[ arg_map.get(op_str["%[".len .. colon orelse open - "]".len]) orelse return self.fail("no matching constraint: '{s}'", .{op_str}) ]) { @@ -178191,7 +178198,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { it = unwrapped_asm.iterateOutputs(); while (it.next()) |out| { - const arg_mcv = args.items[it.current - 1]; + const arg_mcv = args[it.current - 1]; if (out.operand == .none) continue; if (arg_mcv != .register) continue; if (out.constraint.len == 2 and std.ascii.isDigit(out.constraint[1])) continue; @@ -178638,6 +178645,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .lea_uav, .lea_lazy_sym, .lea_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -178653,6 +178661,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .dead, .undef, .register_overflow, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -178844,6 +178853,7 @@ fn genSetReg( .unreach, .dead, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -179422,6 +179432,7 @@ fn genSetMem( .unreach, .dead, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -181569,142 +181580,139 @@ fn resolveCallingConventionValues( .x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space), } - // Return values - if (ret_ty.isNoReturn(zcu)) { - result.return_value = .init(.unreach); - } else if (!ret_ty.hasRuntimeBits(zcu)) { - // TODO: is this even possible for C calling convention? - result.return_value = .init(.none); - } else { - var ret_tracking: [4]InstTracking = undefined; - var ret_tracking_len: u32 = 0; - var ret_gpr = abi.getCAbiIntReturnRegs(cc); - var ret_sse = abi.getCAbiSseReturnRegs(cc); - var ret_x87 = abi.getCAbiX87ReturnRegs(cc); + result.return_value = switch (ret_ty.classify(zcu)) { + .no_possible_value => .init(.unreach), + .one_possible_value => .init(.none), + .runtime, .partially_comptime => return_value: { + var ret_tracking: [4]InstTracking = undefined; + var ret_tracking_len: u32 = 0; + var ret_gpr = abi.getCAbiIntReturnRegs(cc); + var ret_sse = abi.getCAbiSseReturnRegs(cc); + var ret_x87 = abi.getCAbiX87ReturnRegs(cc); - var classes_buf: [8]abi.Class = undefined; - const classes = classes: switch (cc) { - else => unreachable, - .x86_64_sysv => { - classes_buf = abi.classifySystemV(ret_ty, zcu, cg.target, .ret); - break :classes std.mem.sliceTo(&classes_buf, .none); - }, - .x86_64_win => { - classes_buf[0] = abi.classifyWindows(ret_ty, zcu, cg.target, .ret); - break :classes classes_buf[0..1]; - }, - }; - for (classes) |class| switch (class) { - .integer => { - ret_tracking[ret_tracking_len] = .init(.{ .register = registerAlias( - ret_gpr[0], - @intCast(@min(ret_ty.abiSize(zcu), 8)), - ) }); - ret_tracking_len += 1; - ret_gpr = ret_gpr[1..]; - }, - .sse, .float, .float_combine, .win_i128 => { - ret_tracking[ret_tracking_len] = .init(.{ - .register = registerAlias(ret_sse[0], @intCast(ret_ty.abiSize(zcu))), - }); - ret_tracking_len += 1; - ret_sse = ret_sse[1..]; - }, - .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)), - .x87 => { - ret_tracking[ret_tracking_len] = .init(.{ .register = ret_x87[0] }); - ret_tracking_len += 1; - ret_x87 = ret_x87[1..]; - }, - .x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)), - .none => unreachable, - .memory => { - ret_tracking[ret_tracking_len] = .{ - .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } }, - .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }, - }; - ret_tracking_len += 1; - ret_gpr = ret_gpr[1..]; - param_gpr_index += 1; - }, - .integer_per_element => { - const len: u32 = @intCast(ret_ty.vectorLen(zcu)); - const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); - for (ret_tracking[ret_tracking_len..][0..len], ret_gpr[0..len]) |*tracking, gpr| - tracking.* = .init(.{ .register = registerAlias(gpr, alias_size) }); - ret_tracking_len += len; - ret_gpr = ret_gpr[len..]; - }, - .sse_per_element => { - const len: u32 = @intCast(ret_ty.vectorLen(zcu)); - const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); - for (ret_tracking[ret_tracking_len..][0..len], ret_sse[0..len]) |*tracking, sse| - tracking.* = .init(.{ .register = registerAlias(sse, alias_size) }); - ret_tracking_len += len; - ret_sse = ret_sse[len..]; - }, - .sse_sse_x87_per_qword, .sse_per_xword, .sse_per_yword, .sse_per_zword => { - const reg_size: u32 = switch (class) { - else => unreachable, - .sse_sse_x87_per_qword => 8, - .sse_per_xword => 16, - .sse_per_yword => 32, - .sse_per_zword => 64, - }; - var byte_offset: u32 = 0; - const unaligned_size = cg.unalignedSize(ret_ty); - while (byte_offset < unaligned_size) : (byte_offset += reg_size) { - switch (@as(enum { sse, x87 }, switch (class) { + var classes_buf: [8]abi.Class = undefined; + const classes = classes: switch (cc) { + else => unreachable, + .x86_64_sysv => { + classes_buf = abi.classifySystemV(ret_ty, zcu, cg.target, .ret); + break :classes &classes_buf; + }, + .x86_64_win => { + classes_buf[0] = abi.classifyWindows(ret_ty, zcu, cg.target, .ret); + break :classes classes_buf[0..1]; + }, + }; + for (classes) |class| switch (class) { + .integer => { + ret_tracking[ret_tracking_len] = .init(.{ .register = registerAlias( + ret_gpr[0], + @intCast(@min(ret_ty.abiSize(zcu), 8)), + ) }); + ret_tracking_len += 1; + ret_gpr = ret_gpr[1..]; + }, + .sse, .float, .float_combine, .win_i128 => { + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_sse[0], @intCast(ret_ty.abiSize(zcu))), + }); + ret_tracking_len += 1; + ret_sse = ret_sse[1..]; + }, + .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)), + .x87 => { + ret_tracking[ret_tracking_len] = .init(.{ .register = ret_x87[0] }); + ret_tracking_len += 1; + ret_x87 = ret_x87[1..]; + }, + .x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)), + .none => {}, + .memory => { + ret_tracking[ret_tracking_len] = .{ + .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } }, + .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }, + }; + ret_tracking_len += 1; + ret_gpr = ret_gpr[1..]; + param_gpr_index += 1; + }, + .integer_per_element => { + const len: u32 = @intCast(ret_ty.vectorLen(zcu)); + const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); + for (ret_tracking[ret_tracking_len..][0..len], ret_gpr[0..len]) |*tracking, gpr| + tracking.* = .init(.{ .register = registerAlias(gpr, alias_size) }); + ret_tracking_len += len; + ret_gpr = ret_gpr[len..]; + }, + .sse_per_element => { + const len: u32 = @intCast(ret_ty.vectorLen(zcu)); + const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); + for (ret_tracking[ret_tracking_len..][0..len], ret_sse[0..len]) |*tracking, sse| + tracking.* = .init(.{ .register = registerAlias(sse, alias_size) }); + ret_tracking_len += len; + ret_sse = ret_sse[len..]; + }, + .sse_sse_x87_per_qword, .sse_per_xword, .sse_per_yword, .sse_per_zword => { + const reg_size: u32 = switch (class) { else => unreachable, - .sse_sse_x87_per_qword => switch (byte_offset) { - 0 => .sse, // duck - 8 => .sse, // duck - else => .x87, // goose! - }, - .sse_per_xword, .sse_per_yword, .sse_per_zword => .sse, - })) { - .sse => { - ret_tracking[ret_tracking_len] = .init(.{ - .register = registerAlias(ret_sse[0], reg_size), - }); - ret_tracking_len += 1; - ret_sse = ret_sse[1..]; - }, - .x87 => { - ret_tracking[ret_tracking_len] = .init(.{ - .register = registerAlias(ret_x87[0], reg_size), - }); - ret_tracking_len += 1; - ret_x87 = ret_x87[1..]; - }, + .sse_sse_x87_per_qword => 8, + .sse_per_xword => 16, + .sse_per_yword => 32, + .sse_per_zword => 64, + }; + var byte_offset: u32 = 0; + const unaligned_size = cg.unalignedSize(ret_ty); + while (byte_offset < unaligned_size) : (byte_offset += reg_size) { + switch (@as(enum { sse, x87 }, switch (class) { + else => unreachable, + .sse_sse_x87_per_qword => switch (byte_offset) { + 0 => .sse, // duck + 8 => .sse, // duck + else => .x87, // goose! + }, + .sse_per_xword, .sse_per_yword, .sse_per_zword => .sse, + })) { + .sse => { + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_sse[0], reg_size), + }); + ret_tracking_len += 1; + ret_sse = ret_sse[1..]; + }, + .x87 => { + ret_tracking[ret_tracking_len] = .init(.{ + .register = registerAlias(ret_x87[0], reg_size), + }); + ret_tracking_len += 1; + ret_x87 = ret_x87[1..]; + }, + } } - } - }, - }; - result.return_value = switch (ret_tracking_len) { - else => unreachable, - 1 => ret_tracking[0], - 2 => .init(.{ .register_pair = .{ - ret_tracking[0].short.register, - ret_tracking[1].short.register, - } }), - 3 => .init(.{ .register_triple = .{ - ret_tracking[0].short.register, - ret_tracking[1].short.register, - ret_tracking[2].short.register, - } }), - 4 => .init(.{ .register_quadruple = .{ - ret_tracking[0].short.register, - ret_tracking[1].short.register, - ret_tracking[2].short.register, - ret_tracking[3].short.register, - } }), - }; - } + }, + }; + break :return_value switch (ret_tracking_len) { + else => unreachable, + 1 => ret_tracking[0], + 2 => .init(.{ .register_pair = .{ + ret_tracking[0].short.register, + ret_tracking[1].short.register, + } }), + 3 => .init(.{ .register_triple = .{ + ret_tracking[0].short.register, + ret_tracking[1].short.register, + ret_tracking[2].short.register, + } }), + 4 => .init(.{ .register_quadruple = .{ + ret_tracking[0].short.register, + ret_tracking[1].short.register, + ret_tracking[2].short.register, + ret_tracking[3].short.register, + } }), + }; + }, + .fully_comptime => unreachable, + }; - // Input params - params: for (param_types, result.args) |ty, *arg| { - assert(ty.hasRuntimeBits(zcu)); + params: for (0.., param_types, result.args) |param_index, ty, *arg| { result.air_arg_count += 1; switch (cc) { else => unreachable, @@ -181726,7 +181734,7 @@ fn resolveCallingConventionValues( else => unreachable, .x86_64_sysv => { classes_buf = abi.classifySystemV(ty, zcu, cg.target, .arg); - break :classes std.mem.sliceTo(&classes_buf, .none); + break :classes &classes_buf; }, .x86_64_win => { classes_buf[0] = abi.classifyWindows(ty, zcu, cg.target, .arg); @@ -181749,12 +181757,28 @@ fn resolveCallingConventionValues( var byte_offset: u32 = 0; while (byte_offset < abi_size) : (byte_offset += reg_size) { if (param_sse_index >= param_sse.len) break :classes; - - const param_sse_reg = registerAlias(param_sse[param_sse_index], reg_size); + arg_mcv[arg_mcv_len] = arg_mcv: { + const param_sse_reg = + registerAlias(param_sse[param_sse_index], reg_size); + switch (cc) { + else => unreachable, + .x86_64_sysv => {}, + .x86_64_win => if (param_index >= fn_info.param_types.len) { + const param_gpr_reg = + registerAlias(param_gpr[param_gpr_index], reg_size); + param_gpr_index += 1; + break :arg_mcv .{ .register_tee = .{ + param_sse_reg, + param_gpr_reg, + .none, + .none, + } }; + }, + } + break :arg_mcv .{ .register = param_sse_reg }; + }; + arg_mcv_len += 1; param_sse_index += 1; - - arg_mcv[arg_mcv_len] = .{ .register = param_sse_reg }; - arg_mcv_len += 1; } }, .sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)), @@ -181764,13 +181788,16 @@ fn resolveCallingConventionValues( .x87, .x87up, .memory => break, }, .x86_64_win => if (param_gpr_index < param_gpr.len) { - arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }; + arg_mcv[arg_mcv_len] = .{ .indirect = .{ + .reg = param_gpr[param_gpr_index].to64(), + } }; arg_mcv_len += 1; param_gpr_index += 1; } else { assert(arg_mcv_len == 0); const param_align = Type.usize.abiAlignment(zcu); - result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count)); + result.stack_byte_count = + @intCast(param_align.forward(result.stack_byte_count)); result.stack_align = result.stack_align.max(param_align); arg.* = .{ .indirect_load_frame = .{ .index = stack_frame_base, @@ -181781,7 +181808,7 @@ fn resolveCallingConventionValues( }, else => unreachable, }, - .none => unreachable, + .none => {}, .integer_per_element, .sse_per_element, .sse_per_xword, @@ -181850,6 +181877,7 @@ fn resolveCallingConventionValues( } else { arg.* = switch (arg_mcv_len) { else => unreachable, + 0 => .none, 1 => arg_mcv[0], 2 => .{ .register_pair = .{ arg_mcv[0].register, @@ -181899,82 +181927,82 @@ fn resolveCallingConventionValues( param_gpr = param_gpr[0 .. param_gpr.len - 1]; } - // Return values - result.return_value = if (ret_ty.isNoReturn(zcu)) - .init(.unreach) - else if (!ret_ty.hasRuntimeBits(zcu)) - .init(.none) - else return_value: { - const ret_gpr = abi.getCAbiIntReturnRegs(cc); - const ret_size: u31 = @intCast(ret_ty.abiSize(zcu)); - if (abi.zigcc.return_in_regs) switch (cg.regClassForType(ret_ty)) { - .general_purpose, .gphi => if (ret_size <= @as(u4, switch (cg.target.cpu.arch) { - else => unreachable, - .x86 => 4, - .x86_64 => 8, - })) - break :return_value .init(.{ .register = registerAlias(ret_gpr[0], ret_size) }) - else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu)) - break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }), - .segment, .mmx, .ip, .cr, .dr => unreachable, - .x87 => if (ret_size <= 16) break :return_value .init(.{ .register = .st0 }), - .sse => if (ret_size <= cg.vectorSize(.float)) break :return_value .init(.{ - .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), - }), - }; - const ret_indirect_reg = param_gpr[0]; - param_gpr = param_gpr[1..]; - break :return_value .{ - .short = .{ .indirect = .{ .reg = ret_gpr[0] } }, - .long = .{ .indirect = .{ .reg = ret_indirect_reg } }, - }; + result.return_value = switch (ret_ty.classify(zcu)) { + .no_possible_value => .init(.unreach), + .one_possible_value => .init(.none), + .runtime, .partially_comptime => return_value: { + const ret_gpr = abi.getCAbiIntReturnRegs(cc); + const ret_size: u31 = @intCast(ret_ty.abiSize(zcu)); + if (abi.zigcc.return_in_regs) switch (cg.regClassForType(ret_ty)) { + .general_purpose, .gphi => if (ret_size <= @as(u4, switch (cg.target.cpu.arch) { + else => unreachable, + .x86 => 4, + .x86_64 => 8, + })) + break :return_value .init(.{ .register = registerAlias(ret_gpr[0], ret_size) }) + else if (ret_gpr.len >= 2 and ret_ty.isSliceAtRuntime(zcu)) + break :return_value .init(.{ .register_pair = ret_gpr[0..2].* }), + .segment, .mmx, .ip, .cr, .dr => unreachable, + .x87 => if (ret_size <= 16) break :return_value .init(.{ .register = .st0 }), + .sse => if (ret_size <= cg.vectorSize(.float)) break :return_value .init(.{ + .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), + }), + }; + const ret_indirect_reg = param_gpr[0]; + param_gpr = param_gpr[1..]; + break :return_value .{ + .short = .{ .indirect = .{ .reg = ret_gpr[0] } }, + .long = .{ .indirect = .{ .reg = ret_indirect_reg } }, + }; + }, + .fully_comptime => unreachable, }; - // Input params - for (param_types, result.args) |param_ty, *arg| { - if (!param_ty.hasRuntimeBits(zcu)) { - arg.* = .none; - continue; - } - result.air_arg_count += 1; - const param_size: u31 = @intCast(param_ty.abiSize(zcu)); - if (abi.zigcc.params_in_regs) switch (cg.regClassForType(param_ty)) { - .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (cg.target.cpu.arch) { - else => unreachable, - .x86 => 4, - .x86_64 => 8, - })) { - arg.* = .{ .register = registerAlias(param_gpr[0], param_size) }; - param_gpr = param_gpr[1..]; - continue; - } else if (param_gpr.len >= 2 and param_ty.isSliceAtRuntime(zcu)) { - arg.* = .{ .register_pair = param_gpr[0..2].* }; - param_gpr = param_gpr[2..]; - continue; - }, - .segment, .mmx, .ip, .cr, .dr => unreachable, - .x87 => if (param_x87.len >= 1 and param_size <= 16) { - arg.* = .{ .register = param_x87[0] }; - param_x87 = param_x87[1..]; - continue; - }, - .sse => if (param_sse.len >= 1 and param_size <= cg.vectorSize(.float)) { - arg.* = .{ - .register = registerAlias(param_sse[0], @max(param_size, 16)), - }; - param_sse = param_sse[1..]; - continue; - }, - }; - const param_align = param_ty.abiAlignment(zcu); - result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count)); - result.stack_align = result.stack_align.max(param_align); - arg.* = .{ .load_frame = .{ - .index = stack_frame_base, - .off = result.stack_byte_count, - } }; - result.stack_byte_count += param_size; - } + for (param_types, result.args) |param_ty, *arg| switch (param_ty.classify(zcu)) { + .no_possible_value => arg.* = .unreach, + .one_possible_value => arg.* = .none, + .runtime, .partially_comptime => { + result.air_arg_count += 1; + const param_size: u31 = @intCast(param_ty.abiSize(zcu)); + if (abi.zigcc.params_in_regs) switch (cg.regClassForType(param_ty)) { + .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (cg.target.cpu.arch) { + else => unreachable, + .x86 => 4, + .x86_64 => 8, + })) { + arg.* = .{ .register = registerAlias(param_gpr[0], param_size) }; + param_gpr = param_gpr[1..]; + continue; + } else if (param_gpr.len >= 2 and param_ty.isSliceAtRuntime(zcu)) { + arg.* = .{ .register_pair = param_gpr[0..2].* }; + param_gpr = param_gpr[2..]; + continue; + }, + .segment, .mmx, .ip, .cr, .dr => unreachable, + .x87 => if (param_x87.len >= 1 and param_size <= 16) { + arg.* = .{ .register = param_x87[0] }; + param_x87 = param_x87[1..]; + continue; + }, + .sse => if (param_sse.len >= 1 and param_size <= cg.vectorSize(.float)) { + arg.* = .{ + .register = registerAlias(param_sse[0], @max(param_size, 16)), + }; + param_sse = param_sse[1..]; + continue; + }, + }; + const param_align = param_ty.abiAlignment(zcu); + result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count)); + result.stack_align = result.stack_align.max(param_align); + arg.* = .{ .load_frame = .{ + .index = stack_frame_base, + .off = result.stack_byte_count, + } }; + result.stack_byte_count += param_size; + }, + .fully_comptime => unreachable, + }; }, else => return cg.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}), } @@ -182241,13 +182269,11 @@ fn typeOfIndex(self: *CodeGen, inst: Air.Inst.Index) Type { return Temp.typeOf(.{ .index = inst }, self); } -fn promoteInt(self: *CodeGen, ty: Type) Type { - const pt = self.pt; +fn promoteInt(cg: *CodeGen, ty: Type) Type { + const pt = cg.pt; const zcu = pt.zcu; - const int_info: InternPool.Key.IntType = switch (ty.toIntern()) { - .bool_type => .{ .signedness = .unsigned, .bits = 1 }, - else => if (ty.isAbiInt(zcu)) ty.intInfo(zcu) else return ty, - }; + const int_info = cg.intInfo(ty) orelse return ty; + if (int_info.bits == 0) return .void; for ([_]Type{ .c_int, .c_uint, .c_long, .c_ulong, @@ -182424,6 +182450,7 @@ const Temp = struct { .lea_lazy_sym, .lea_extern_func, .load_extern_func, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -182891,6 +182918,7 @@ const Temp = struct { .register_overflow, .register_mask, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -188002,6 +188030,7 @@ const Temp = struct { .unreach, .dead, .indirect_load_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, @@ -190673,6 +190702,7 @@ const Select = struct { .lea_extern_func => |extern_func| .{ .imm = .{ .extern_func = extern_func } }, else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) }, .lea_frame, + .register_tee, .elementwise_gpr, .elementwise_sse, .xwordwise_sse, diff --git a/src/codegen/x86_64/abi.zig b/src/codegen/x86_64/abi.zig index e14a2c86deafda632f386619df3fbb264ea9c6fd..111e6d208c310b11d2b4584f5986cdfab96c4bf5 100644 --- a/src/codegen/x86_64/abi.zig +++ b/src/codegen/x86_64/abi.zig @@ -37,6 +37,8 @@ pub const Class = enum { /// Clang passes each 64 bytes in a separate `Class.sse`. sse_per_zword, + pub const zero_bit: [8]Class = .{ .none, .none, .none, .none, .none, .none, .none, .none }; + pub const one_integer: [8]Class = .{ .integer, .none, .none, .none, .none, .none, .none, .none }; pub const two_integers: [8]Class = .{ .integer, .integer, .none, .none, .none, .none, .none, .none }; pub const three_integers: [8]Class = .{ .integer, .integer, .integer, .none, .none, .none, .none, .none }; @@ -100,12 +102,11 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: // as if they were integers of the same size." var ty = init_ty; while (true) return switch (ty.zigTypeTag(zcu)) { + .void => return .none, + .bool, .pointer, .int, - .bool, .@"enum", - .void, - .noreturn, .error_set, .@"struct", .@"union", @@ -115,7 +116,7 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: .@"anyframe", .frame, => switch (ty.abiSize(zcu)) { - 0 => unreachable, + 0 => .none, 1, 2, 4, 8 => .integer, else => switch (ty.zigTypeTag(zcu)) { .int => .win_i128, @@ -126,6 +127,7 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: else => .memory, }, }, + .noreturn => unreachable, .float => switch (ty.floatBits(target)) { 16, 32, 64 => .sse, 80 => .memory, @@ -134,6 +136,7 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: }, .vector => { const len = ty.vectorLen(zcu); + if (len == 0) return .none; const elem_ty = ty.childType(zcu); if (len == 1) { ty = elem_ty; @@ -178,19 +181,18 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: /// the beginning of the array; unused slots are filled with .none. pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Context) [8]Class { switch (ty.zigTypeTag(zcu)) { - .pointer => switch (ty.ptrSize(zcu)) { - .slice => return Class.two_integers, - else => return Class.one_integer, - }, + .void => return Class.zero_bit, + .bool => return Class.one_integer, + .noreturn => unreachable, .int, .@"enum", .error_set => { const bits = ty.intInfo(zcu).bits; + if (bits == 0) return Class.zero_bit; if (bits <= 64 * 1) return Class.one_integer; if (bits <= 64 * 2) return Class.two_integers; if (bits <= 64 * 3) return Class.three_integers; if (bits <= 64 * 4) return Class.four_integers; return Class.stack; }, - .bool, .void, .noreturn => return Class.one_integer, .float => switch (ty.floatBits(target)) { 16 => { if (ctx == .other) return Class.stack; @@ -209,9 +211,13 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont 80 => return Class.f80, else => unreachable, }, + .pointer => switch (ty.ptrSize(zcu)) { + .slice => return Class.two_integers, + else => return Class.one_integer, + }, .vector => { const len = ty.vectorLen(zcu); - if (len == 0) return Class.one_integer; + if (len == 0) return Class.zero_bit; const elem_ty = ty.childType(zcu); if (elem_ty.toIntern() == .bool_type) { if (len <= 32) return Class.one_integer; @@ -275,6 +281,7 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont // "If the size of the aggregate exceeds a single eightbyte, each is classified // separately.". const ty_size = ty.abiSize(zcu); + if (ty_size == 0) return Class.zero_bit; switch (ty.containerLayout(zcu)) { .auto => unreachable, .@"extern" => {}, @@ -325,6 +332,7 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont }, .array => { const ty_size = ty.abiSize(zcu); + if (ty_size == 0) return Class.zero_bit; if (ty_size <= 8) return Class.one_integer; if (ty_size <= 16) return Class.two_integers; return Class.stack; diff --git a/test/c_abi/cfuncs.c b/test/c_abi/cfuncs.c index 271d16ba7586910805baf7c68a1c62a1c065bc73..302503ad4d839449c9aad546e712f3ebb6bdff3d 100644 --- a/test/c_abi/cfuncs.c +++ b/test/c_abi/cfuncs.c @@ -16211,3 +16211,18 @@ void __attribute__((vectorcall)) c_vectorcall_check(int a, float b, double c, vo zig_vectorcall_check(a, b, c, d, e, f, g, h, i, j); } #endif + +#if defined(__x86_64__) && defined(_WIN64) +void c_win64_varargs_u64_f64_u64_f64(uint64_t a, double b, uint64_t c, double d) { + assert_or_panic(a == UINT64_C(0x3ff0000000000000)); + assert_or_panic(b == 2.0); + assert_or_panic(c == UINT64_C(0x4008000000000000)); + assert_or_panic(d == 4.0); +} +void c_win64_varargs_f64_u64_f64_u64(double a, uint64_t b, double c, uint64_t d) { + assert_or_panic(a == 5.0); + assert_or_panic(b == UINT64_C(0x4018000000000000)); + assert_or_panic(c == 7.0); + assert_or_panic(d == UINT64_C(0x4020000000000000)); +} +#endif diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig index 331805e878635b545e531d5ac1ad6900f8e74592..132d8dcf6ade1ee902287f874d74f8b95781ab1c 100644 --- a/test/c_abi/main.zig +++ b/test/c_abi/main.zig @@ -17140,9 +17140,7 @@ test "byval tail callsite attribute" { } test "x86 fastcall calling convention" { - if (builtin.cpu.arch != .x86) return error.SkipZigTest; - if (builtin.os.tag != .windows) return error.SkipZigTest; - if (builtin.abi != .msvc) return error.SkipZigTest; + if (builtin.cpu.arch != .x86 or builtin.os.tag != .windows or builtin.abi != .msvc) return error.SkipZigTest; const static = struct { const fastcall: std.builtin.CallingConvention = .{ .x86_fastcall = .{} }; @@ -17252,9 +17250,7 @@ test "x86 fastcall calling convention" { } test "x86 vectorcall calling convention" { - if (builtin.cpu.arch != .x86) return error.SkipZigTest; - if (builtin.os.tag != .windows) return error.SkipZigTest; - if (builtin.abi != .msvc) return error.SkipZigTest; + if (builtin.cpu.arch != .x86 or builtin.os.tag != .windows or builtin.abi != .msvc) return error.SkipZigTest; const static = struct { extern fn c_vectorcall_check(a: c_int, b: f32, c: f64, d: *anyopaque, e: f32, f: f64, g: f64, h: f32, i: f32, j: c_int) callconv(.{ .x86_vectorcall = .{} }) void; @@ -17273,3 +17269,34 @@ test "x86 vectorcall calling convention" { }; static.c_vectorcall_check(1, 2.0, 3.0, @ptrFromInt(4), 5.0, 6.0, 7.0, 8.0, 9.0, 10); } + +extern fn c_win64_varargs_u64_f64_u64_f64(...) void; +extern fn c_win64_varargs_f64_u64_f64_u64(...) void; + +test "win64 varargs" { + if (builtin.cpu.arch != .x86_64 or builtin.os.tag != .windows) return error.SkipZigTest; + + const Opv = extern struct {}; + c_win64_varargs_u64_f64_u64_f64( + @as(Opv, .{}), + @as(f32, 1), + @as(Opv, .{}), + @as(f32, 2.0), + @as(Opv, .{}), + @as(f64, 3), + @as(Opv, .{}), + @as(f64, 4.0), + @as(Opv, .{}), + ); + c_win64_varargs_f64_u64_f64_u64( + @as(Opv, .{}), + @as(f32, 5), + @as(Opv, .{}), + @as(f32, 6.0), + @as(Opv, .{}), + @as(f64, 7), + @as(Opv, .{}), + @as(f64, 8.0), + @as(Opv, .{}), + ); +} -- 2.54.0 From 8ecc942ce890768f556e870bea1d66fe7bad8936 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Sat, 20 Jun 2026 05:41:03 -0400 Subject: [PATCH 4/4] x86_64: implement win64 abi for bool vectors --- src/codegen/llvm/FuncGen.zig | 4 + src/codegen/x86_64/CodeGen.zig | 2190 ++++++++++++++++++++++++++++---- src/codegen/x86_64/abi.zig | 4 +- src/dev.zig | 14 + test/c_abi/main.zig | 5 - 5 files changed, 1933 insertions(+), 284 deletions(-) diff --git a/src/codegen/llvm/FuncGen.zig b/src/codegen/llvm/FuncGen.zig index d7ae7ea93bb4d6fde7d37a1c753470eb6e0392da..f8114041843c3ae402498a1162e3c522a15c8b8a 100644 --- a/src/codegen/llvm/FuncGen.zig +++ b/src/codegen/llvm/FuncGen.zig @@ -6790,6 +6790,7 @@ const ParamTypeIterator = struct { } }, .sse, + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -6874,6 +6875,7 @@ const ParamTypeIterator = struct { .none => break, .memory => unreachable, // handled above .win_i128 => unreachable, // windows only + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -7091,6 +7093,7 @@ fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Err } }, .sse, + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -7156,6 +7159,7 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E .none => break, .memory => return .void, .win_i128 => unreachable, // windows only + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig index 85f02b32ccf7dbb7c26f2ef7f59afc78a60f7e46..692810bf86c8a39a9a0b3772e04b9f0fa97fffc0 100644 --- a/src/codegen/x86_64/CodeGen.zig +++ b/src/codegen/x86_64/CodeGen.zig @@ -164,7 +164,7 @@ next_temp_index: Temp.Index = @enumFromInt(0), temp_type: [Temp.Index.max]Type = undefined, const MaskInfo = packed struct { - kind: enum(u1) { sign, all }, + kind: enum(u2) { lsb, msb, zero_extend, sign_extend }, inverted: bool = false, scalar: Memory.Size, }; @@ -204,13 +204,15 @@ pub const MCValue = union(enum) { /// The value is a tuple { wrapped, overflow } where wrapped value is stored in the GP register. register_overflow: struct { reg: Register, eflags: Condition }, /// The value is a bool vector stored in a vector register with a different scalar type. - register_mask: struct { reg: Register, info: MaskInfo }, + register_mask: Mask, /// The value is in memory at a hard-coded address. /// If the type is a pointer, it means the pointer address is stored at this memory location. memory: u64, /// The value is in memory at a constant offset from the address in a register. indirect: bits.RegisterOffset, indirect_load_frame: bits.FrameAddr, + /// The value is a bool vector stored in memory with a different scalar type at the address in a register. + indirect_mask: Mask, /// The value stored at an offset from a frame index. /// Payload is a frame address. load_frame: bits.FrameAddr, @@ -243,6 +245,8 @@ pub const MCValue = union(enum) { reserved_frame: FrameIndex, air_ref: Air.Inst.Ref, + const Mask = struct { reg: Register, info: MaskInfo }; + fn isModifiable(mcv: MCValue) bool { return switch (mcv) { .none, @@ -278,6 +282,7 @@ pub const MCValue = union(enum) { .register_quadruple, .memory, .indirect, + .indirect_mask, .load_nav, => true, .load_frame => |frame_addr| !frame_addr.index.isNamed(), @@ -346,9 +351,10 @@ pub const MCValue = union(enum) { .register_quadruple, => |*regs| regs, inline .register_offset, - .indirect, .register_overflow, .register_mask, + .indirect, + .indirect_mask, => |*pl| (&pl.reg)[0..1], else => &.{}, }; @@ -384,6 +390,7 @@ pub const MCValue = union(enum) { .register_offset, .register_overflow, .register_mask, + .indirect_mask, .lea_frame, .lea_nav, .lea_uav, @@ -427,6 +434,7 @@ pub const MCValue = union(enum) { .memory, .indirect, .indirect_load_frame, + .indirect_mask, .load_nav, .load_uav, .load_lazy_sym, @@ -476,6 +484,7 @@ pub const MCValue = union(enum) { .memory, .indirect, .indirect_load_frame, + .indirect_mask, .load_frame, .load_nav, .lea_nav, @@ -547,6 +556,10 @@ pub const MCValue = union(enum) { .disp = reg_off.off + mod_rm.disp, } }, }, + .indirect_mask => |reg_mask| .{ + .base = .{ .reg = reg_mask.reg.toSize(.ptr, function.target) }, + .mod = .{ .rm = mod_rm }, + }, .load_frame => |frame_addr| .{ .base = .{ .frame = frame_addr.index }, .mod = .{ .rm = .{ @@ -568,7 +581,6 @@ pub const MCValue = union(enum) { switch (mcv) { .none, .unreach, .dead, .undef => try w.print("({s})", .{@tagName(mcv)}), .immediate => |pl| try w.print("0x{x}", .{pl}), - .memory => |pl| try w.print("[ds:0x{x}]", .{pl}), inline .eflags, .register => |pl| try w.print("{s}", .{@tagName(pl)}), .register_pair => |pl| try w.print("{s}:{s}", .{ @tagName(pl[1]), @tagName(pl[0]) }), .register_triple => |pl| try w.print("{s}:{s}:{s}", .{ @@ -582,14 +594,21 @@ pub const MCValue = union(enum) { @tagName(pl.eflags), @tagName(pl.reg), }), - .register_mask => |pl| try w.print("mask({s},{f}):{c}{s}", .{ + .register_mask => |pl| try w.print("mask({s},{f}):{s}{s}", .{ @tagName(pl.info.kind), pl.info.scalar, - @as(u8, if (pl.info.inverted) '!' else ' '), + if (pl.info.inverted) "!" else "", @tagName(pl.reg), }), + .memory => |pl| try w.print("[ds:0x{x}]", .{pl}), .indirect => |pl| try w.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }), .indirect_load_frame => |pl| try w.print("[[{f} + 0x{x}]]", .{ pl.index, pl.off }), + .indirect_mask => |pl| try w.print("[mask({s},{f}):{s}{s}]", .{ + @tagName(pl.info.kind), + pl.info.scalar, + if (pl.info.inverted) "!" else "", + @tagName(pl.reg), + }), .load_frame => |pl| try w.print("[{f} + 0x{x}]", .{ pl.index, pl.off }), .lea_frame => |pl| try w.print("{f} + 0x{x}", .{ pl.index, pl.off }), .load_nav => |pl| try w.print("[nav:{d}]", .{@intFromEnum(pl)}), @@ -666,6 +685,7 @@ const InstTracking = struct { .register_overflow, .register_mask, .indirect, + .indirect_mask, => .none, }, .short = result }; } @@ -765,6 +785,7 @@ const InstTracking = struct { .register_overflow, .register_mask, .indirect, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -72517,7 +72538,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72541,7 +72562,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72565,7 +72586,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -72593,7 +72614,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -72622,7 +72643,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -72651,7 +72672,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -72718,7 +72739,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72744,7 +72765,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72770,7 +72791,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -72800,7 +72821,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -72831,7 +72852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -72862,7 +72883,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -72932,7 +72953,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72958,7 +72979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -72984,7 +73005,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73014,7 +73035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73045,7 +73066,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -73076,7 +73097,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -73146,8 +73167,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73172,8 +73193,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73198,7 +73219,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73224,8 +73245,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73253,8 +73274,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -73323,8 +73344,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73350,8 +73371,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73377,7 +73398,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73404,8 +73425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73435,8 +73456,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -73508,8 +73529,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73535,8 +73556,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73562,7 +73583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73590,8 +73611,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73621,8 +73642,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .word, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -73694,8 +73715,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73720,8 +73741,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73746,7 +73767,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73773,8 +73794,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, .unused, @@ -73844,8 +73865,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73871,8 +73892,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73898,7 +73919,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -73926,8 +73947,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, .unused, @@ -74000,8 +74021,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74027,8 +74048,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74054,7 +74075,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74082,8 +74103,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .reverse } }, + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .reverse } } }, .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, .unused, @@ -74156,8 +74177,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .qword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74182,8 +74203,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .qword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74208,7 +74229,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .unused, .unused, .unused, @@ -74279,7 +74300,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .unused, .unused, @@ -74307,7 +74328,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .unused, .unused, .unused, @@ -74381,8 +74402,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .qword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74408,8 +74429,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .qword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74435,7 +74456,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, .unused, .unused, .unused, @@ -74509,8 +74530,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74535,8 +74556,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74561,8 +74582,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, @@ -74594,8 +74615,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, .unused, @@ -74627,8 +74648,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, @@ -74660,8 +74681,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, .unused, @@ -74693,8 +74714,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .repeat = 2, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -74720,8 +74741,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .none, .none } }, }, .extra_temps = .{ - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -74752,8 +74773,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, + .{ .type = .vector_32_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .repeat = 2, .size = .xword } } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, @@ -74788,8 +74809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .forward } }, - .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .reverse, .size = .xword } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -82067,7 +82088,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, @@ -82107,7 +82128,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, @@ -82147,7 +82168,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, @@ -82171,7 +82192,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { @@ -82194,7 +82215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { @@ -82216,7 +82237,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) { @@ -82238,7 +82259,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -82261,7 +82282,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -82283,7 +82304,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) { @@ -82305,7 +82326,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -82328,7 +82349,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -82350,7 +82371,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { @@ -82373,7 +82394,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { @@ -82395,7 +82416,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) { @@ -82417,7 +82438,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -82440,7 +82461,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -82462,7 +82483,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) { @@ -82484,7 +82505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -82507,7 +82528,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -84711,7 +84732,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84735,7 +84756,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84759,7 +84780,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84783,7 +84804,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84807,7 +84828,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84831,7 +84852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84855,7 +84876,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84879,7 +84900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84903,7 +84924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84927,7 +84948,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84951,7 +84972,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84975,7 +84996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -84999,7 +85020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -85023,7 +85044,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -85047,7 +85068,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse, .none } }, }, .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ - .kind = .all, + .kind = .sign_extend, .inverted = switch (cc) { else => unreachable, .e => false, @@ -86699,7 +86720,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, @@ -86739,7 +86760,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, @@ -86779,7 +86800,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, @@ -86805,7 +86826,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { @@ -86828,7 +86849,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) { @@ -86852,7 +86873,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -86875,7 +86896,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) { @@ -86899,7 +86920,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .dword }, + .info = .{ .kind = .sign_extend, .scalar = .dword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -86923,7 +86944,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { @@ -86946,7 +86967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) { @@ -86970,7 +86991,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { @@ -86993,7 +87014,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .{ .ref_mask = .{ .ref = .src0, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) { @@ -87017,7 +87038,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, - .info = .{ .kind = .all, .scalar = .qword }, + .info = .{ .kind = .sign_extend, .scalar = .qword }, } }, .unused }, .each = .{ .once = &.{ .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { @@ -89392,6 +89413,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .store, .store_safe => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); + switch (ops[1].tracking(cg).short) { + else => {}, + .register_mask => |src_reg_mask| { + const ty = ops[1].typeOf(cg); + const new_op1 = try cg.tempAllocReg(ty, abi.RegisterClass.gp); + try cg.genSetReg( + new_op1.tracking(cg).short.register, + ty, + .{ .register_mask = src_reg_mask }, + .{ .safety = switch (air_tag) { + else => unreachable, + .store => false, + .store_safe => true, + } }, + ); + try ops[1].die(cg); + ops[1] = new_op1; + }, + } cg.select(&.{}, &.{}, &ops, comptime &.{ .{ .src_constraints = .{ .{ .ptr_bool_vec_elem = .byte }, .bool, .any }, .patterns = &.{ @@ -127167,7 +127207,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend, .is = .inverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .z }, .unused }, .clobbers = .{ .eflags = true }, @@ -127179,7 +127219,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend, .is = .inverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .z }, .unused }, .clobbers = .{ .eflags = true }, @@ -127191,7 +127231,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -127217,7 +127257,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -127243,7 +127283,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -127269,7 +127309,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -127295,7 +127335,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend, .is = .inverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .z }, .unused }, .clobbers = .{ .eflags = true }, @@ -127307,7 +127347,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend, .is = .inverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .z }, .unused }, .clobbers = .{ .eflags = true }, @@ -127319,7 +127359,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, @@ -127345,7 +127385,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, @@ -127371,7 +127411,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -127572,7 +127612,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend, .is = .uninverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .nz }, .unused }, .clobbers = .{ .eflags = true }, @@ -127584,7 +127624,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend, .is = .uninverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .nz }, .unused }, .clobbers = .{ .eflags = true }, @@ -127596,7 +127636,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -127622,7 +127662,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -127648,7 +127688,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -127674,7 +127714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -127700,7 +127740,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend, .is = .uninverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .nz }, .unused }, .clobbers = .{ .eflags = true }, @@ -127712,7 +127752,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend, .is = .uninverted } }, .none, .none } }, }, .dst_temps = .{ .{ .cc = .nz }, .unused }, .clobbers = .{ .eflags = true }, @@ -127724,7 +127764,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, @@ -127750,7 +127790,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .sign_extend } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, @@ -127776,7 +127816,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_constraints = .{ .bool, .any }, .src_constraints = .{ .any_bool_vec, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } }, + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .msb } }, .none, .none } }, }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, @@ -174528,6 +174568,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -174586,6 +174627,7 @@ fn store( .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -174636,6 +174678,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .lea_frame, .lea_nav, .lea_uav, @@ -175336,6 +175379,7 @@ fn genBinOpMir( .lea_lazy_sym, .lea_extern_func, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -175378,6 +175422,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -175555,6 +175600,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -175664,6 +175710,7 @@ fn genBinOpMir( .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -175793,7 +175840,13 @@ fn airArg(cg: *CodeGen, inst: Air.Inst.Index) !void { const result: MCValue = if (cg.mod.strip and cg.liveness.isUnused(inst)) .unreach else result: { const arg_ty = cg.typeOfIndex(inst); switch (src_mcv) { - .register, .register_pair, .load_frame => { + .register, + .register_pair, + .register_triple, + .register_quadruple, + .register_mask, + .load_frame, + => { for (src_mcv.getRegs()) |reg| cg.register_manager.getRegAssumeFree(reg, inst); break :result src_mcv; }, @@ -175803,6 +175856,22 @@ fn airArg(cg: *CodeGen, inst: Air.Inst.Index) !void { try cg.genCopy(arg_ty, dst_mcv, src_mcv, .{}); break :result dst_mcv; }, + .indirect_mask => |reg_mask| { + cg.register_manager.getRegAssumeFree(reg_mask.reg, null); + const dst_reg = try cg.register_manager.allocReg(inst, abi.RegisterClass.sse); + const mask_size: u32 = @intCast( + @divExact(reg_mask.info.scalar.bitSize(cg.target), 8) * arg_ty.vectorLen(zcu), + ); + try cg.asmRegisterMemory( + .{ if (cg.hasFeature(.avx)) .v_dqa else ._dqa, .mov }, + registerAlias(dst_reg, mask_size), + .{ + .base = .{ .reg = reg_mask.reg }, + .mod = .{ .rm = .{ .size = .fromSize(mask_size) } }, + }, + ); + break :result .{ .register_mask = .{ .reg = dst_reg, .info = reg_mask.info } }; + }, .indirect_load_frame => |frame_addr| { const dst_mcv = try cg.allocRegOrMem(inst, false); const ptr_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); @@ -176265,6 +176334,10 @@ fn genCall(cg: *CodeGen, info: union(enum) { for (regs) |reg| try cg.register_manager.getReg(reg, null); try reg_locks.appendSlice(allocator, &cg.register_manager.lockRegs(regs.len, regs)); }, + .register_mask => |reg_mask| { + try cg.register_manager.getReg(reg_mask.reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(reg_mask.reg)); + }, .indirect => |reg_off| { frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu)); try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts); @@ -176282,6 +176355,44 @@ fn genCall(cg: *CodeGen, info: union(enum) { opts, ); }, + .indirect_mask => |reg_mask| { + var src = switch (src_arg) { + else => try cg.tempInit(arg_ty, src_arg), + .air_ref => |src_ref| try cg.tempFromOperand(src_ref, false), + }; + var dst = try cg.tempInit(arg_ty, .{ .register_mask = .{ + .reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse), + .info = reg_mask.info, + } }); + dst.copyToMask(&src, cg) catch |err| switch (err) { + error.SelectFailed => return cg.fail("failed to select arg {f} {f} {f}", .{ + arg_ty.fmt(pt), + dst.tracking(cg), + src.tracking(cg), + }), + else => |e| return e, + }; + try src.die(cg); + const mask_size: u32 = @intCast( + @divExact(reg_mask.info.scalar.bitSize(cg.target), 8) * arg_ty.vectorLen(zcu), + ); + frame_index.* = try cg.allocFrameIndex(.init(.{ + .size = mask_size, + .alignment = .fromByteUnits(std.math.ceilPowerOfTwoAssert(u32, mask_size)), + })); + try cg.asmMemoryRegister( + .{ if (cg.hasFeature(.avx)) .v_dqa else ._dqa, .mov }, + .{ + .base = .{ .frame = frame_index.* }, + .mod = .{ .rm = .{ .size = .fromSize(mask_size) } }, + }, + registerAlias(dst.tracking(cg).short.register_mask.reg, mask_size), + ); + try dst.die(cg); + + try cg.register_manager.getReg(reg_mask.reg, null); + try reg_locks.append(allocator, cg.register_manager.lockReg(reg_mask.reg)); + }, .load_frame => { try cg.genCopy(arg_ty, dst_arg, src_arg, opts); try cg.freeValue(src_arg, .{}); @@ -176396,7 +176507,7 @@ fn genCall(cg: *CodeGen, info: union(enum) { var frame_offset: i32 = regs_frame_addr.info.frame_off; var arg_offset = elem_size * param_gpr_len; - while (arg_size - arg_offset != 0) : ({ + while (arg_size - arg_offset > 0) : ({ frame_offset += 8; arg_offset += elem_size; }) try cg.genSetMem( @@ -176458,8 +176569,28 @@ fn genCall(cg: *CodeGen, info: union(enum) { .register_triple, .register_quadruple, => try cg.genCopy(arg_ty, dst_arg, src_arg, opts), - .indirect => |reg_off| try cg.genSetReg(reg_off.reg, .usize, .{ - .lea_frame = .{ .index = frame_index, .off = -reg_off.off }, + .register_mask => { + var src = switch (src_arg) { + else => try cg.tempInit(arg_ty, src_arg), + .air_ref => |src_ref| try cg.tempFromOperand(src_ref, false), + }; + var dst = try cg.tempInit(arg_ty, dst_arg); + dst.copyToMask(&src, cg) catch |err| switch (err) { + error.SelectFailed => return cg.fail("failed to select arg {f} {f} {f}", .{ + arg_ty.fmt(pt), + dst.tracking(cg), + src.tracking(cg), + }), + else => |e| return e, + }; + try src.die(cg); + try dst.die(cg); + }, + .indirect => |dst_reg_off| try cg.genSetReg(dst_reg_off.reg, .usize, .{ + .lea_frame = .{ .index = frame_index, .off = -dst_reg_off.off }, + }, opts), + .indirect_mask => |dst_reg_mask| try cg.genSetReg(dst_reg_mask.reg, .usize, .{ + .lea_frame = .{ .index = frame_index }, }, opts), .register_tee => |dst_regs| { try cg.genSetReg(dst_regs[0], arg_ty, src_arg, opts); @@ -176570,31 +176701,43 @@ fn genCall(cg: *CodeGen, info: union(enum) { return call_info.return_value.short; } -fn airRet(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { - const pt = self.pt; - const zcu = pt.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; +fn airRet(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { + const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const ret_ty = self.fn_type.fnReturnType(zcu); - switch (self.ret_mcv.short) { + const ret_ty = cg.fn_type.fnReturnType(cg.pt.zcu); + switch (cg.ret_mcv.short) { .none => {}, .register => |reg| { - const reg_lock = self.register_manager.lockRegAssumeUnused(reg); - defer self.register_manager.unlockReg(reg_lock); - try self.genCopy(ret_ty, self.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety }); + const reg_lock = cg.register_manager.lockRegAssumeUnused(reg); + defer cg.register_manager.unlockReg(reg_lock); + try cg.genCopy(ret_ty, cg.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety }); }, inline .register_pair, .register_triple, .register_quadruple => |regs| { - const reg_locks = self.register_manager.lockRegsAssumeUnused(regs.len, regs); - defer for (reg_locks) |reg_lock| self.register_manager.unlockReg(reg_lock); - try self.genCopy(ret_ty, self.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety }); + const reg_locks = cg.register_manager.lockRegsAssumeUnused(regs.len, regs); + defer for (reg_locks) |reg_lock| cg.register_manager.unlockReg(reg_lock); + try cg.genCopy(ret_ty, cg.ret_mcv.short, .{ .air_ref = un_op }, .{ .safety = safety }); + }, + .register_mask => { + var src = try cg.tempFromOperand(un_op, true); + var dst = try cg.tempInit(ret_ty, cg.ret_mcv.short); + dst.copyToMask(&src, cg) catch |err| switch (err) { + error.SelectFailed => return cg.fail("failed to select ret {f} {f} {f}", .{ + ret_ty.fmt(cg.pt), + dst.tracking(cg), + src.tracking(cg), + }), + else => |e| return e, + }; + try src.die(cg); + try dst.die(cg); }, .indirect => |reg_off| { - try self.register_manager.getReg(reg_off.reg, null); - const lock = self.register_manager.lockRegAssumeUnused(reg_off.reg); - defer self.register_manager.unlockReg(lock); + try cg.register_manager.getReg(reg_off.reg, null); + const lock = cg.register_manager.lockRegAssumeUnused(reg_off.reg); + defer cg.register_manager.unlockReg(lock); - try self.genSetReg(reg_off.reg, .usize, self.ret_mcv.long, .{}); - try self.genSetMem( + try cg.genSetReg(reg_off.reg, .usize, cg.ret_mcv.long, .{}); + try cg.genSetMem( .{ .reg = reg_off.reg }, reg_off.off, ret_ty, @@ -176604,59 +176747,78 @@ fn airRet(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { }, else => unreachable, } - self.ret_mcv.liveOut(self, inst); + cg.ret_mcv.liveOut(cg, inst); - if (self.err_ret_trace_reg != .none) { - if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { + if (cg.err_ret_trace_reg != .none) { + if (cg.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { if (switch (err_ret_trace.short) { - .register => |reg| self.err_ret_trace_reg != reg, + .register => |reg| cg.err_ret_trace_reg != reg, else => true, - }) try self.genSetReg(self.err_ret_trace_reg, .usize, err_ret_trace.short, .{}); - err_ret_trace.liveOut(self, err_ret_trace_index); + }) try cg.genSetReg(cg.err_ret_trace_reg, .usize, err_ret_trace.short, .{}); + err_ret_trace.liveOut(cg, err_ret_trace_index); } } - try self.finishAir(inst, .unreach, .{ un_op, .none, .none }); + try cg.finishAir(inst, .unreach, .{ un_op, .none, .none }); // TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction // which is available if the jump is 127 bytes or less forward. - const jmp_reloc = try self.asmJmpReloc(undefined); - try self.epilogue_relocs.append(self.gpa, jmp_reloc); + const jmp_reloc = try cg.asmJmpReloc(undefined); + try cg.epilogue_relocs.append(cg.gpa, jmp_reloc); } -fn airRetLoad(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const ptr = try self.resolveInst(un_op); - - const ptr_ty = self.typeOf(un_op); - switch (self.ret_mcv.short) { +fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void { + const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + switch (cg.ret_mcv.short) { .none => {}, .register, .register_pair, .register_triple, .register_quadruple, - => try self.load(self.ret_mcv.short, ptr_ty, ptr), - .indirect => |reg_off| try self.genSetReg(reg_off.reg, ptr_ty, ptr, .{}), + => try cg.load(cg.ret_mcv.short, cg.typeOf(un_op), try cg.resolveInst(un_op)), + .register_mask => { + var ptr = try cg.tempFromOperand(un_op, true); + const ret_ty = ptr.typeOf(cg).childType(cg.pt.zcu); + var src = try ptr.load(ret_ty, .{}, cg); + try ptr.die(cg); + var dst = try cg.tempInit(ret_ty, cg.ret_mcv.short); + dst.copyToMask(&src, cg) catch |err| switch (err) { + error.SelectFailed => return cg.fail("failed to select ret_load {f} {f} {f}", .{ + ret_ty.fmt(cg.pt), + dst.tracking(cg), + src.tracking(cg), + }), + else => |e| return e, + }; + try src.die(cg); + try dst.die(cg); + }, + .indirect => |dst_reg_off| try cg.genSetReg( + dst_reg_off.reg, + cg.typeOf(un_op), + try cg.resolveInst(un_op), + .{}, + ), else => unreachable, } - self.ret_mcv.liveOut(self, inst); + cg.ret_mcv.liveOut(cg, inst); - if (self.err_ret_trace_reg != .none) { - if (self.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { + if (cg.err_ret_trace_reg != .none) { + if (cg.inst_tracking.getPtr(err_ret_trace_index)) |err_ret_trace| { if (switch (err_ret_trace.short) { - .register => |reg| self.err_ret_trace_reg != reg, + .register => |reg| cg.err_ret_trace_reg != reg, else => true, - }) try self.genSetReg(self.err_ret_trace_reg, .usize, err_ret_trace.short, .{}); - err_ret_trace.liveOut(self, err_ret_trace_index); + }) try cg.genSetReg(cg.err_ret_trace_reg, .usize, err_ret_trace.short, .{}); + err_ret_trace.liveOut(cg, err_ret_trace_index); } } - try self.finishAir(inst, .unreach, .{ un_op, .none, .none }); + try cg.finishAir(inst, .unreach, .{ un_op, .none, .none }); // TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction // which is available if the jump is 127 bytes or less forward. - const jmp_reloc = try self.asmJmpReloc(undefined); - try self.epilogue_relocs.append(self.gpa, jmp_reloc); + const jmp_reloc = try cg.asmJmpReloc(undefined); + try cg.epilogue_relocs.append(cg.gpa, jmp_reloc); } fn airTry(self: *CodeGen, inst: Air.Inst.Index) !void { @@ -178640,6 +178802,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .lea_frame, .lea_nav, .lea_uav, @@ -178853,6 +179016,7 @@ fn genSetReg( .unreach, .dead, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -179282,33 +179446,105 @@ fn genSetReg( const bits_lock = cg.register_manager.lockReg(bits_reg); defer if (bits_lock) |lock| cg.register_manager.unlockReg(lock); + var mask_size: u32 = @intCast( + @divExact(src_reg_mask.info.scalar.bitSize(cg.target), 8) * ty.vectorLen(zcu), + ); + const sign_reg = switch (src_reg_mask.info.kind) { + .lsb => sign_reg: { + const sign_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse); + const src_alias = registerAlias(src_reg_mask.reg, mask_size); + const sign_alias = registerAlias(sign_reg, mask_size); + if (cg.hasFeature(.avx2)) try cg.asmRegisterRegisterImmediate( + .{ switch (src_reg_mask.info.scalar) { + else => unreachable, + .byte, .word => .vp_w, + .dword => .vp_d, + .qword => .vp_q, + }, .sll }, + sign_alias, + src_alias, + .u(src_reg_mask.info.scalar.bitSize(cg.target) - 1), + ) else { + if (sign_alias != src_alias) try cg.asmRegisterRegister( + .{ ._dqa, .mov }, + sign_alias, + src_alias, + ); + try cg.asmRegisterImmediate( + .{ switch (src_reg_mask.info.scalar) { + else => unreachable, + .byte, .word => .p_w, + .dword => .p_d, + .qword => .p_q, + }, .sll }, + sign_alias, + .u(src_reg_mask.info.scalar.bitSize(cg.target) - 1), + ); + } + break :sign_reg sign_reg; + }, + .zero_extend => sign_reg: { + const sign_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse); + const src_alias = registerAlias(src_reg_mask.reg, mask_size); + const sign_alias = registerAlias(sign_reg, mask_size); + if (has_avx) { + try cg.asmRegisterRegisterRegister( + .{ .vp_, .xor }, + sign_alias, + sign_alias, + sign_alias, + ); + try cg.asmRegisterRegisterRegister(.{ switch (src_reg_mask.info.scalar) { + else => unreachable, + .byte => .vp_b, + .word => .vp_w, + .dword => .vp_d, + .qword => .vp_q, + }, .sub }, sign_alias, sign_alias, src_alias); + } else { + try cg.asmRegisterRegister(.{ .p_, .xor }, sign_alias, sign_alias); + try cg.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) { + else => unreachable, + .byte => .p_b, + .word => .p_w, + .dword => .p_d, + .qword => .p_q, + }, .sub }, sign_alias, src_alias); + } + break :sign_reg sign_reg; + }, + .msb, .sign_extend => src_reg_mask.reg, + }; + const sign_lock = cg.register_manager.lockReg(sign_reg); + defer if (sign_lock) |lock| cg.register_manager.unlockReg(lock); + const pack_reg = switch (src_reg_mask.info.scalar) { - else => src_reg_mask.reg, - .word => try cg.register_manager.allocReg(null, abi.RegisterClass.sse), - }; - const pack_lock = cg.register_manager.lockReg(pack_reg); - defer if (pack_lock) |lock| cg.register_manager.unlockReg(lock); - - var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(cg.target), 8)); - switch (src_reg_mask.info.scalar) { - else => {}, - .word => { - const src_alias = registerAlias(src_reg_mask.reg, mask_size); + else => sign_reg, + .word => pack_reg: { + const pack_reg = if (sign_reg == src_reg_mask.reg) + try cg.register_manager.allocReg(null, abi.RegisterClass.sse) + else + sign_reg; + const sign_alias = registerAlias(sign_reg, mask_size); const pack_alias = registerAlias(pack_reg, mask_size); if (has_avx) { - try cg.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias); + try cg.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, sign_alias, sign_alias); } else { - try cg.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias); + if (pack_alias != sign_alias) try cg.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, sign_alias); try cg.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias); } mask_size = std.math.divCeil(u32, mask_size, 2) catch unreachable; + break :pack_reg pack_reg; }, - } + }; + const pack_lock = cg.register_manager.lockReg(pack_reg); + defer if (pack_lock) |lock| cg.register_manager.unlockReg(lock); + try cg.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) { + else => unreachable, .byte, .word => if (has_avx) .vp_b else .p_b, .dword => if (has_avx) .v_ps else ._ps, .qword => if (has_avx) .v_pd else ._pd, - else => unreachable, }, .movmsk }, bits_reg.to32(), registerAlias(pack_reg, mask_size)); if (src_reg_mask.info.inverted) try cg.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size)); try cg.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{}); @@ -179432,6 +179668,7 @@ fn genSetMem( .unreach, .dead, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -180697,32 +180934,32 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { const dst_lock = self.register_manager.lockReg(dst_reg); defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); - const mir_tag = @as(?Mir.Inst.FixedTag, if ((pred_reg_mask.info.kind == .all and + const mir_tag = @as(?Mir.Inst.FixedTag, if ((pred_reg_mask.info.kind == .sign_extend and elem_ty.toIntern() != .f32_type and elem_ty.toIntern() != .f64_type) or pred_reg_mask.info.scalar == .byte) if (has_avx) .{ .vp_b, .blendv } else if (has_blend) .{ .p_b, .blendv } - else if (pred_reg_mask.info.kind == .all) + else if (pred_reg_mask.info.kind == .sign_extend) .{ .p_, undefined } else null - else if ((pred_reg_mask.info.kind == .all and (elem_ty.toIntern() != .f64_type or !self.hasFeature(.sse2))) or + else if ((pred_reg_mask.info.kind == .sign_extend and (elem_ty.toIntern() != .f64_type or !self.hasFeature(.sse2))) or pred_reg_mask.info.scalar == .dword) if (has_avx) .{ .v_ps, .blendv } else if (has_blend) .{ ._ps, .blendv } - else if (pred_reg_mask.info.kind == .all) + else if (pred_reg_mask.info.kind == .sign_extend) .{ ._ps, undefined } else null - else if (pred_reg_mask.info.kind == .all or pred_reg_mask.info.scalar == .qword) + else if (pred_reg_mask.info.kind == .sign_extend or pred_reg_mask.info.scalar == .qword) if (has_avx) .{ .v_pd, .blendv } else if (has_blend) .{ ._pd, .blendv } - else if (pred_reg_mask.info.kind == .all) + else if (pred_reg_mask.info.kind == .sign_extend) .{ ._pd, undefined } else null @@ -181635,6 +181872,17 @@ fn resolveCallingConventionValues( ret_gpr = ret_gpr[1..]; param_gpr_index += 1; }, + .bool_vector_mask => { + const len = ret_ty.vectorLen(zcu); + const elem_size = + @divExact(16, std.math.ceilPowerOfTwoAssert(u32, @min(len, 16))); + ret_tracking[ret_tracking_len] = .init(.{ .register_mask = .{ + .reg = registerAlias(ret_sse[0], elem_size * len), + .info = .{ .kind = .lsb, .scalar = .fromSize(elem_size) }, + } }); + ret_tracking_len += 1; + ret_sse = ret_sse[1..]; + }, .integer_per_element => { const len: u32 = @intCast(ret_ty.vectorLen(zcu)); const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8)); @@ -181809,6 +182057,17 @@ fn resolveCallingConventionValues( else => unreachable, }, .none => {}, + .bool_vector_mask => { + arg_mcv[arg_mcv_len] = .{ .indirect_mask = .{ + .reg = param_gpr[param_gpr_index].to64(), + .info = .{ .kind = .lsb, .scalar = .fromSize(@divExact( + 16, + std.math.ceilPowerOfTwoAssert(u32, @min(ty.vectorLen(zcu), 16)), + )) }, + } }; + arg_mcv_len += 1; + param_gpr_index += 1; + }, .integer_per_element, .sse_per_element, .sse_per_xword, @@ -182441,6 +182700,7 @@ const Temp = struct { .memory, .indirect, .indirect_load_frame, + .indirect_mask, .lea_frame, .load_nav, .lea_nav, @@ -182918,6 +183178,7 @@ const Temp = struct { .register_overflow, .register_mask, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -183423,6 +183684,7 @@ const Temp = struct { .x87up, .none, .win_i128, + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -183440,6 +183702,7 @@ const Temp = struct { .x87up, .none, .win_i128, + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -183464,6 +183727,7 @@ const Temp = struct { .memory, .none, .win_i128, + .bool_vector_mask, .integer_per_element, .sse_per_element, .sse_sse_x87_per_qword, @@ -183502,6 +183766,1331 @@ const Temp = struct { try cg.asmOpOnly(.{ .@"rep _sb", .sto }); } + fn copyToMask(dst: *Temp, src: *Temp, cg: *CodeGen) Select.Error!void { + var ops: [2]Temp = .{ dst.*, src.* }; + try cg.select(&.{}, &.{}, &ops, comptime &.{ .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_q, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_q, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_q, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_b, .shuf, .src0x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_mut_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .shuf, .src1x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src1x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src1x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_q, .sub, .src0x, .src1x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpckldq, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .src0x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 2 }, .{ .exact_bool_vec = 2 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_mut_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 8 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .tmp2x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpckldq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_q, .sub, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_b, .shuf, .src0x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_mut_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .shuf, .src1x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src1x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src1x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .src1x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpckldq, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .src0x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 4 }, .{ .exact_bool_vec = 4 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 4 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .tmp2x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpckldq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1b, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_b, .broadcast, .src0x, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .tmp2x, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp2x, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp2x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_b, .shuf, .src0x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_mut_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .shuf, .src1x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src1x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src1x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .src1x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpckldq, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .src0x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 8 }, .{ .exact_bool_vec = 8 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward, .smear = 2 } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .tmp2x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpckldq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklqdq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lea(.tmp2x), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3x, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp3x, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lea(.tmp2x), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3x, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp3x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lea(.tmp2x), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp3x, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lea(.tmp2x), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp3x, ._ }, + .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp3x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_b, .shuf, .src0x, .lea(.tmp2x), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, ._, .movddup, .tmp3x, .lea(.tmp2q), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp3x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp3x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_mut_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .word, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .p_b, .shuf, .src1x, .lea(.tmp2x), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, ._, .movddup, .src0x, .lea(.tmp2q), ._, ._ }, + .{ ._, .p_, .@"and", .src1x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src1x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .src1x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpckldq, .src0x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._, .movddup, .tmp2x, .lea(.tmp1q), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse3, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .tmp2x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpckldq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._, .movddup, .src0x, .lea(.tmp1q), ._, ._ }, + .{ ._, .p_, .@"and", .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .src0x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .src0x, .src0x, ._, ._ }, + .{ ._, .p_, .unpckldq, .src0x, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 16 }, .{ .exact_bool_vec = 16 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .xword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._dqa, .mov, .tmp2x, .src1x, ._, ._ }, + .{ ._, .p_, .unpcklbw, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpcklwd, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_, .unpckldq, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, .p_, .@"and", .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_b, .cmpeq, .tmp2x, .src0x, ._, ._ }, + .{ ._, .p_, .xor, .src0x, .src0x, ._, ._ }, + .{ ._, .p_b, .sub, .src0x, .tmp2x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_sign_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_d, .broadcast, .src0y, .src1d, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0y, .src0y, .lea(.tmp2y), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_b, .cmpeq, .src0y, .src0y, .tmp3y, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_d, .broadcast, .src0y, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0y, .src0y, .lea(.tmp2y), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_b, .cmpeq, .src0y, .src0y, .tmp3y, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_zero_extend, .is = .uninverted } }, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_d, .broadcast, .src0y, .src1d, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0y, .src0y, .lea(.tmp2y), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_b, .cmpeq, .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp3y, ._ }, + .{ ._, .vp_b, .sub, .src0y, .tmp3y, .src0y, ._ }, + } }, + }, .{ + .required_features = .{ .avx2, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_8_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, .vp_d, .broadcast, .src0y, .src1x, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .src0y, .src0y, .lea(.tmp2y), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp2q), ._, ._ }, + .{ ._, .vp_, .@"and", .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_b, .cmpeq, .src0y, .src0y, .tmp3y, ._ }, + .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp3y, ._ }, + .{ ._, .vp_b, .sub, .src0y, .tmp3y, .src0y, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_sign_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .tmp3x, .src1x, .lea(.tmp2y), ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lead(.tmp2y, 16), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp4x, .lea(.tmp2x), ._, ._ }, + .{ ._, .vp_, .@"and", .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp4x, ._ }, + .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp4x, ._ }, + .{ ._, .v_f128, .insert, .src0y, .tmp3y, .src0x, .ui(1) }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .exact_bool_vec = 32 }, .{ .exact_bool_vec = 32 }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .reg_mask = .{ .size = .yword, .kind = .from_zero_extend, .is = .uninverted } }, .to_sse, .none } }, + }, + .extra_temps = .{ + .{ .type = .vector_32_u8, .kind = .{ .pshufb_bytes_mem = .{ .direction = .forward, .size = .dword, .smear = 8 } } }, + .{ .type = .vector_16_u8, .kind = .{ .bits_mem = .{ .direction = .forward } } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, + .{ ._, .vp_b, .shuf, .tmp3x, .src1x, .lea(.tmp2y), ._ }, + .{ ._, .vp_b, .shuf, .src0x, .src1x, .lead(.tmp2y, 16), ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp4x, .lea(.tmp2x), ._, ._ }, + .{ ._, .vp_, .@"and", .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_, .@"and", .src0x, .src0x, .tmp4x, ._ }, + .{ ._, .vp_b, .cmpeq, .tmp3x, .tmp3x, .tmp4x, ._ }, + .{ ._, .vp_b, .cmpeq, .src0x, .src0x, .tmp4x, ._ }, + .{ ._, .vp_, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, + .{ ._, .vp_b, .sub, .tmp3x, .tmp4x, .tmp3x, ._ }, + .{ ._, .vp_b, .sub, .src0x, .tmp4x, .src0x, ._ }, + .{ ._, .v_f128, .insert, .src0y, .tmp3y, .src0x, .ui(1) }, + } }, + } }); + dst.*, src.* = ops; + } + fn wrapInt(temp: *Temp, cg: *CodeGen) Select.Error!void { var ops: [1]Temp = .{temp.*}; var res: [1]Temp = undefined; @@ -188030,6 +189619,7 @@ const Temp = struct { .unreach, .dead, .indirect_load_frame, + .indirect_mask, .register_tee, .elementwise_gpr, .elementwise_sse, @@ -188885,25 +190475,60 @@ const Select = struct { to_sse, mut_sse, to_mut_sse, - reg_mask: RegMaskSpec, - all_reg_mask: RegMaskSpec, - - const RegMaskSpec = struct { + reg_mask: struct { size: Memory.Size, + kind: enum { + any, + lsb, + msb, + zero_extend, + sign_extend, + from_lsb, + from_msb, + from_zero_extend, + from_sign_extend, + }, is: enum { any, uninverted, inverted, - - fn matches(is: @This(), inverted: bool) bool { - return switch (is) { - .any => true, - .uninverted => !inverted, - .inverted => inverted, - }; - } } = .any, - }; + + fn matches(spec: @This(), info: MaskInfo) bool { + return switch (spec.kind) { + .any => true, + .lsb => switch (info.kind) { + .lsb, .msb, .zero_extend, .sign_extend => true, + }, + .msb => switch (info.kind) { + .lsb, .zero_extend => false, + .msb, .sign_extend => true, + }, + .zero_extend => info.kind == .zero_extend, + .sign_extend => info.kind == .sign_extend, + .from_lsb => switch (info.kind) { + .lsb => true, + .msb, .zero_extend, .sign_extend => false, + }, + .from_msb => switch (info.kind) { + .lsb, .msb => true, + .zero_extend, .sign_extend => false, + }, + .from_sign_extend => switch (info.kind) { + .lsb, .msb, .sign_extend => true, + .zero_extend => false, + }, + .from_zero_extend => switch (info.kind) { + .lsb, .zero_extend => true, + .msb, .sign_extend => false, + }, + } and switch (spec.is) { + .any => true, + .uninverted => !info.inverted, + .inverted => info.inverted, + }; + } + }, fn matches(src: Src, temp: Temp, cg: *CodeGen) bool { return switch (src) { @@ -188988,13 +190613,7 @@ const Select = struct { .reg_mask => |mask_spec| switch (temp.tracking(cg).short) { .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) >= reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and - mask_spec.is.matches(reg_mask.info.inverted), - else => false, - }, - .all_reg_mask => |mask_spec| switch (temp.tracking(cg).short) { - .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) == - reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and - reg_mask.info.kind == .all and mask_spec.is.matches(reg_mask.info.inverted), + mask_spec.matches(reg_mask.info), else => false, }, }; @@ -189002,7 +190621,7 @@ const Select = struct { fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool { return switch (src) { - .none, .any, .imm, .imm8, .imm16, .imm32, .simm32, .reg_mask, .all_reg_mask => false, + .none, .any, .imm, .imm8, .imm16, .imm32, .simm32, .reg_mask => false, .mem, .to_mem => try temp.toBase(false, cg), .mut_mem, .to_mut_mem => try temp.toBase(true, cg), .to_reg => |reg| try temp.toReg(reg, cg), @@ -189073,8 +190692,8 @@ const Select = struct { pand_trunc_mem: struct { from: Memory.Size, to: Memory.Size }, pand_mask_mem: struct { ref: Select.Operand.Ref, invert: bool = false }, ptest_mask_mem: Select.Operand.Ref, - pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 }, - bits_mem: enum { forward, reverse }, + pshufb_bytes_mem: struct { direction: Direction, repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 }, + bits_mem: struct { direction: Direction, smear: u4 = 1 }, splat_int_mem: struct { ref: Select.Operand.Ref, inside: enum { umin, smin, smax } = .umin, outside: enum { smin, smax } }, splat_float_mem: struct { ref: Select.Operand.Ref, inside: enum { zero } = .zero, outside: f16 }, frame: FrameIndex, @@ -189109,6 +190728,8 @@ const Select = struct { } }; + const Direction = enum { forward, reverse }; + fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock { var reg_locks: [2]?RegisterLock = @splat(null); const regs: [2]Register = switch (kind) { @@ -189430,11 +191051,15 @@ const Select = struct { var index: u7 = 0; for (0..@intCast(ref_ty.vectorLen(zcu))) |_| { switch (mask_info.kind) { - .sign => { + .lsb, .zero_extend => { + elems[index] = 1; + @memset(elems[index + 1 ..][0 .. elem_bytes - 1], std.math.minInt(u8)); + }, + .msb => { @memset(elems[index..][0 .. elem_bytes - 1], std.math.minInt(u8)); elems[index + elem_bytes - 1] = @bitCast(@as(i8, std.math.minInt(i8))); }, - .all => @memset(elems[index..][0..elem_bytes], std.math.maxInt(u8)), + .sign_extend => @memset(elems[index..][0..elem_bytes], std.math.maxInt(u8)), } index += elem_bytes; } @@ -189443,31 +191068,40 @@ const Select = struct { .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, io, pt.tid, elems, .maybe_embedded_nulls) }, } }))), true }; }, - .pshufb_bswap_mem => |bswap_spec| { + .pshufb_bytes_mem => |bytes_spec| { const zcu = pt.zcu; assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); var elem_buf: [32]u8 = @splat(1 << 7); const elems = elem_buf[0..spec.type.vectorLen(zcu)]; - const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8)); + const len: usize = @intCast(@divExact(bytes_spec.size.bitSize(cg.target), 8)); var to_index: u6 = 0; - for (0..bswap_spec.repeat) |_| for (0..len) |from_index| { - @memset(elems[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index)); - to_index += bswap_spec.smear; + for (0..bytes_spec.repeat) |_| for (0..len) |from_index| { + @memset(elems[to_index..][0..bytes_spec.smear], @intCast(switch (bytes_spec.direction) { + .forward => from_index, + .reverse => len - 1 - from_index, + })); + to_index += bytes_spec.smear; }; return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ .ty = spec.type.toIntern(), .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, io, pt.tid, elems, .maybe_embedded_nulls) }, } }))), true }; }, - .bits_mem => |direction| { + .bits_mem => |bits_spec| { const zcu = pt.zcu; assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); - var bytes: [32]u8 = undefined; - const elems = bytes[0..spec.type.vectorLen(zcu)]; - for (elems, 0..) |*elem, index| elem.* = switch (direction) { - .forward => @as(u8, 1 << 0) << @truncate(index), - .reverse => @as(u8, 1 << 7) >> @truncate(index), - }; + var elem_buf: [32]u8 = @splat(1 << 7); + const elems = elem_buf[0..spec.type.vectorLen(zcu)]; + var from_index: u6 = 0; + var to_index: u6 = 0; + while (elems.len - to_index > 0) { + @memset(elems[to_index..][0..bits_spec.smear], @intCast(switch (bits_spec.direction) { + .forward => @as(u8, 1 << 0) << @truncate(from_index), + .reverse => @as(u8, 1 << 7) >> @truncate(from_index), + })); + from_index += 1; + to_index += bits_spec.smear; + } return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ .ty = spec.type.toIntern(), .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, io, pt.tid, elems, .maybe_embedded_nulls) }, diff --git a/src/codegen/x86_64/abi.zig b/src/codegen/x86_64/abi.zig index 111e6d208c310b11d2b4584f5986cdfab96c4bf5..3e7a9a548d54baee16d64a54de9a42c4650f7ea5 100644 --- a/src/codegen/x86_64/abi.zig +++ b/src/codegen/x86_64/abi.zig @@ -24,6 +24,8 @@ pub const Class = enum { float, /// A `Class.sse` containing two `f32`s. float_combine, + /// Clang uses different element sizes depending on the vector length. + bool_vector_mask, /// Clang passes each vector element in a separate `Class.integer`. integer_per_element, /// Clang passes each vector element in a separate `Class.sse`. @@ -150,7 +152,7 @@ pub fn classifyWindows(init_ty: Type, zcu: *Zcu, target: *const std.Target, ctx: .{ 16, .sse_per_xword }; if (elem_ty.toIntern() == .bool_type) { if (len > reg_size) return if (ctx == .arg) .integer_per_element else .memory; - return if (ctx == .arg) .memory else .sse; + return .bool_vector_mask; } const elem_size = elem_ty.abiSize(zcu); const unaligned_size = elem_size * len; diff --git a/src/dev.zig b/src/dev.zig index f3c4016faf2338e1f80b1e96953d207e7fed866f..bba67696f2f92cf522949f68ffc35370f3daf86d 100644 --- a/src/dev.zig +++ b/src/dev.zig @@ -52,6 +52,10 @@ pub const Env = enum { /// - `zig build-* -fincremental -fno-llvm -fno-lld -target x86_64-linux --listen=-` @"x86_64-linux", + /// - sema + /// - `zig build-* -fincremental -fno-llvm -fno-lld -target x86_64-windows --listen=-` + @"x86_64-windows", + pub inline fn supports(comptime dev_env: Env, comptime feature: Feature) bool { return switch (dev_env) { .full => true, @@ -216,6 +220,16 @@ pub const Env = enum { => true, else => Env.sema.supports(feature), }, + .@"x86_64-windows" => switch (feature) { + .build_command, + .stdio_listen, + .incremental, + .legalize, + .x86_64_backend, + .coff2_linker, + => true, + else => Env.sema.supports(feature), + }, }; } diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig index 132d8dcf6ade1ee902287f874d74f8b95781ab1c..5184d0458f23917dd3ae488c4fd560bb0a1d7328 100644 --- a/test/c_abi/main.zig +++ b/test/c_abi/main.zig @@ -295,7 +295,6 @@ extern fn c_test_vector_2_bool() void; test "@Vector(2, bool)" { if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; const vec = c_ret_vector_2_bool(); try expect(vec[0] == true); @@ -337,7 +336,6 @@ extern fn c_test_vector_4_bool() void; test "@Vector(4, bool)" { if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; const vec = c_ret_vector_4_bool(); try expect(vec[0] == true); @@ -391,7 +389,6 @@ extern fn c_test_vector_8_bool() void; test "@Vector(8, bool)" { if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; const vec = c_ret_vector_8_bool(); try expect(vec[0] == false); @@ -469,7 +466,6 @@ extern fn c_test_vector_16_bool() void; test "@Vector(16, bool)" { if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest; const vec = c_ret_vector_16_bool(); try expect(vec[0] == true); @@ -595,7 +591,6 @@ extern fn c_test_vector_32_bool() void; test "@Vector(32, bool)" { if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows and builtin.cpu.has(.x86, .avx)) return error.SkipZigTest; const vec = c_ret_vector_32_bool(); try expect(vec[0] == true); -- 2.54.0