From df4068cabd9af96d0aca1f435b985d1c103976da Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 13 Jun 2025 05:46:15 -0400 Subject: [PATCH 1/6] Build: change how the target is printed in step names e.g. `x86_64-windows.win10...win11_dt-gnu` -> `x86_64-windows-gnu` When the OS version is the default this is redundant with checking the default in the standard library. --- lib/std/Build.zig | 9 ++++++++- lib/std/Build/Step/Compile.zig | 22 +++++++++++++--------- test/behavior/x86_64/build.zig | 7 +++---- test/link/link.zig | 2 +- test/src/Cases.zig | 2 +- test/src/Debugger.zig | 2 +- test/src/LlvmIr.zig | 2 +- test/src/TranslateC.zig | 2 +- test/tests.zig | 4 ++-- 9 files changed, 31 insertions(+), 21 deletions(-) diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 3bfd8c9a7db9..bac7abdd986e 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -1164,7 +1164,14 @@ pub fn addRunArtifact(b: *Build, exe: *Step.Compile) *Step.Run { // It doesn't have to be native. We catch that if you actually try to run it. // Consider that this is declarative; the run step may not be run unless a user // option is supplied. - const run_step = Step.Run.create(b, b.fmt("run {s}", .{exe.name})); + + // Avoid the common case of the step name looking like "run test test". + const step_name = if (exe.kind.isTest() and mem.eql(u8, exe.name, "test")) + b.fmt("run {s}", .{@tagName(exe.kind)}) + else + b.fmt("run {s} {s}", .{ @tagName(exe.kind), exe.name }); + + const run_step = Step.Run.create(b, step_name); run_step.producer = exe; if (exe.kind == .@"test") { if (exe.exec_cmd_args) |exec_cmd_args| { diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig index 924dc18f91be..fa84ac5e6e48 100644 --- a/lib/std/Build/Step/Compile.zig +++ b/lib/std/Build/Step/Compile.zig @@ -292,6 +292,13 @@ pub const Kind = enum { obj, @"test", test_obj, + + pub fn isTest(kind: Kind) bool { + return switch (kind) { + .exe, .lib, .obj => false, + .@"test", .test_obj => true, + }; + } }; pub const HeaderInstallation = union(enum) { @@ -368,19 +375,16 @@ pub fn create(owner: *std.Build, options: Options) *Compile { panic("invalid name: '{s}'. It looks like a file path, but it is supposed to be the library or application name.", .{name}); } - // Avoid the common case of the step name looking like "zig test test". - const name_adjusted = if ((options.kind == .@"test" or options.kind == .test_obj) and mem.eql(u8, name, "test")) - "" - else - owner.fmt("{s} ", .{name}); - const resolved_target = options.root_module.resolved_target orelse @panic("the root Module of a Compile step must be created with a known 'target' field"); const target = resolved_target.result; - const step_name = owner.fmt("compile {s} {s}{s} {s}", .{ - @tagName(options.kind), - name_adjusted, + const step_name = owner.fmt("compile {s} {s} {s}", .{ + // Avoid the common case of the step name looking like "compile test test". + if (options.kind.isTest() and mem.eql(u8, name, "test")) + @tagName(options.kind) + else + owner.fmt("{s} {s}", .{ @tagName(options.kind), name }), @tagName(options.root_module.optimize orelse .Debug), resolved_target.query.zigTriple(owner.allocator) catch @panic("OOM"), }); diff --git a/test/behavior/x86_64/build.zig b/test/behavior/x86_64/build.zig index 8d0e27f96434..5aea349297d0 100644 --- a/test/behavior/x86_64/build.zig +++ b/test/behavior/x86_64/build.zig @@ -115,6 +115,7 @@ pub fn build(b: *std.Build) void { }, }) |query| { const target = b.resolveTargetQuery(query); + const triple = query.zigTriple(b.allocator) catch @panic("OOM"); const cpu = query.serializeCpuAlloc(b.allocator) catch @panic("OOM"); for ([_][]const u8{ "access.zig", @@ -133,16 +134,14 @@ pub fn build(b: *std.Build) void { .use_lld = false, .root_module = test_mod, }); + test_exe.step.name = b.fmt("{s} {s}", .{ test_exe.step.name, cpu }); if (!target.result.cpu.has(.x86, .sse2)) { test_exe.bundle_compiler_rt = false; test_mod.linkLibrary(compiler_rt_lib); } const test_run = b.addRunArtifact(test_exe); + test_run.step.name = b.fmt("{s} {s} {s}", .{ test_run.step.name, triple, cpu }); b.default_step.dependOn(&test_run.step); - for ([_]*std.Build.Step{ - &test_exe.step, - &test_run.step, - }) |step| step.name = b.fmt("{s} {s}", .{ step.name, cpu }); } } } diff --git a/test/link/link.zig b/test/link/link.zig index 59198e6c8eb1..5d1a02f23e69 100644 --- a/test/link/link.zig +++ b/test/link/link.zig @@ -13,7 +13,7 @@ pub const Options = struct { }; pub fn addTestStep(b: *Build, prefix: []const u8, opts: Options) *Step { - const target = opts.target.result.zigTriple(b.allocator) catch @panic("OOM"); + const target = opts.target.query.zigTriple(b.allocator) catch @panic("OOM"); const optimize = @tagName(opts.optimize); const use_llvm = if (opts.use_llvm) "llvm" else "no-llvm"; const use_lld = if (opts.use_lld) "lld" else "no-lld"; diff --git a/test/src/Cases.zig b/test/src/Cases.zig index a36f4f3f7cc8..4c8eed85b63e 100644 --- a/test/src/Cases.zig +++ b/test/src/Cases.zig @@ -610,7 +610,7 @@ pub fn lowerToBuildSteps( if (std.mem.indexOf(u8, case.name, test_filter)) |_| break; } else if (test_filters.len > 0) continue; - const triple_txt = case.target.result.zigTriple(b.allocator) catch @panic("OOM"); + const triple_txt = case.target.query.zigTriple(b.allocator) catch @panic("OOM"); if (test_target_filters.len > 0) { for (test_target_filters) |filter| { diff --git a/test/src/Debugger.zig b/test/src/Debugger.zig index 08202f3130d3..6ed888df1d2d 100644 --- a/test/src/Debugger.zig +++ b/test/src/Debugger.zig @@ -2447,7 +2447,7 @@ fn addTest( } else return; } if (db.options.test_target_filters.len > 0) { - const triple_txt = target.resolved.result.zigTriple(db.b.allocator) catch @panic("OOM"); + const triple_txt = target.resolved.query.zigTriple(db.b.allocator) catch @panic("OOM"); for (db.options.test_target_filters) |filter| { if (std.mem.indexOf(u8, triple_txt, filter) != null) break; } else return; diff --git a/test/src/LlvmIr.zig b/test/src/LlvmIr.zig index f6d39505b957..76200455b95d 100644 --- a/test/src/LlvmIr.zig +++ b/test/src/LlvmIr.zig @@ -75,7 +75,7 @@ pub fn addExact( pub fn addCase(self: *LlvmIr, case: TestCase) void { const target = self.b.resolveTargetQuery(case.params.target); if (self.options.test_target_filters.len > 0) { - const triple_txt = target.result.zigTriple(self.b.allocator) catch @panic("OOM"); + const triple_txt = target.query.zigTriple(self.b.allocator) catch @panic("OOM"); for (self.options.test_target_filters) |filter| { if (std.mem.indexOf(u8, triple_txt, filter) != null) break; } else return; diff --git a/test/src/TranslateC.zig b/test/src/TranslateC.zig index 18d5e1ce50e8..2df7536342f7 100644 --- a/test/src/TranslateC.zig +++ b/test/src/TranslateC.zig @@ -96,7 +96,7 @@ pub fn addCase(self: *TranslateCContext, case: *const TestCase) void { const target = b.resolveTargetQuery(case.target); if (self.test_target_filters.len > 0) { - const triple_txt = target.result.zigTriple(b.allocator) catch @panic("OOM"); + const triple_txt = target.query.zigTriple(b.allocator) catch @panic("OOM"); for (self.test_target_filters) |filter| { if (std.mem.indexOf(u8, triple_txt, filter) != null) break; diff --git a/test/tests.zig b/test/tests.zig index ef0251482acb..500deb84097d 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -2310,8 +2310,8 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { if (options.skip_llvm and would_use_llvm) continue; const resolved_target = b.resolveTargetQuery(test_target.target); + const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); const target = resolved_target.result; - const triple_txt = target.zigTriple(b.allocator) catch @panic("OOM"); if (options.test_target_filters.len > 0) { for (options.test_target_filters) |filter| { @@ -2556,8 +2556,8 @@ pub fn addCAbiTests(b: *std.Build, options: CAbiTestOptions) *Step { if (options.skip_llvm and would_use_llvm) continue; const resolved_target = b.resolveTargetQuery(c_abi_target.target); + const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); const target = resolved_target.result; - const triple_txt = target.zigTriple(b.allocator) catch @panic("OOM"); if (options.test_target_filters.len > 0) { for (options.test_target_filters) |filter| { From 16d78bc0c024da307c7ab5f6b94622e6b4b37397 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 13 Jun 2025 12:01:59 -0400 Subject: [PATCH 2/6] Build: add install commands to `--verbose` output --- build.zig | 8 +-- lib/std/Build.zig | 23 +++++++++ lib/std/Build/Step.zig | 71 ++++++++++++++++++++++++-- lib/std/Build/Step/Compile.zig | 1 + lib/std/Build/Step/InstallArtifact.zig | 55 +++++--------------- lib/std/Build/Step/InstallDir.zig | 38 ++++---------- lib/std/Build/Step/InstallFile.zig | 10 +--- lib/std/Build/Step/ObjCopy.zig | 2 +- lib/std/Build/Step/Run.zig | 23 +++++++-- lib/std/fs/Dir.zig | 18 +++++-- lib/std/fs/path.zig | 8 +-- 11 files changed, 160 insertions(+), 97 deletions(-) diff --git a/build.zig b/build.zig index ce1c89aa1984..c6c624aaee04 100644 --- a/build.zig +++ b/build.zig @@ -203,6 +203,10 @@ pub fn build(b: *std.Build) !void { exe.pie = pie; exe.entitlements = entitlements; + const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend"); + exe.use_llvm = use_llvm; + exe.use_lld = use_llvm; + if (no_bin) { b.getInstallStep().dependOn(&exe.step); } else { @@ -214,10 +218,6 @@ pub fn build(b: *std.Build) !void { test_step.dependOn(&exe.step); - const use_llvm = b.option(bool, "use-llvm", "Use the llvm backend"); - exe.use_llvm = use_llvm; - exe.use_lld = use_llvm; - const exe_options = b.addOptions(); exe.root_module.addOptions("build_options", exe_options); diff --git a/lib/std/Build.zig b/lib/std/Build.zig index bac7abdd986e..ab064d1aea2b 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -2456,12 +2456,23 @@ pub const GeneratedFile = struct { /// This value must be set in the `fn make()` of the `step` and must not be `null` afterwards. path: ?[]const u8 = null, + /// Deprecated, see `getPath2`. pub fn getPath(gen: GeneratedFile) []const u8 { return gen.step.owner.pathFromCwd(gen.path orelse std.debug.panic( "getPath() was called on a GeneratedFile that wasn't built yet. Is there a missing Step dependency on step '{s}'?", .{gen.step.name}, )); } + + pub fn getPath2(gen: GeneratedFile, src_builder: *Build, asking_step: ?*Step) []const u8 { + return gen.path orelse { + std.debug.lockStdErr(); + const stderr = std.io.getStdErr(); + dumpBadGetPathHelp(gen.step, stderr, src_builder, asking_step) catch {}; + std.debug.unlockStdErr(); + @panic("misconfigured build script"); + }; + } }; // dirnameAllowEmpty is a variant of fs.path.dirname @@ -2712,6 +2723,18 @@ pub const LazyPath = union(enum) { } } + pub fn basename(lazy_path: LazyPath, src_builder: *Build, asking_step: ?*Step) []const u8 { + return fs.path.basename(switch (lazy_path) { + .src_path => |sp| sp.sub_path, + .cwd_relative => |sub_path| sub_path, + .generated => |gen| if (gen.sub_path.len > 0) + gen.sub_path + else + gen.file.getPath2(src_builder, asking_step), + .dependency => |dep| dep.sub_path, + }); + } + /// Copies the internal strings. /// /// The `b` parameter is only used for its allocator. All *Build instances diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig index 9cf0ca475ec3..9d4802fbbcbb 100644 --- a/lib/std/Build/Step.zig +++ b/lib/std/Build/Step.zig @@ -478,6 +478,29 @@ pub fn evalZigProcess( return result; } +/// Wrapper around `std.fs.Dir.updateFile` that handles verbose and error output. +pub fn installFile(s: *Step, src_lazy_path: Build.LazyPath, dest_path: []const u8) !std.fs.Dir.PrevStatus { + const b = s.owner; + const src_path = src_lazy_path.getPath3(b, s); + try handleVerbose(b, null, &.{ "install", "-C", b.fmt("{}", .{src_path}), dest_path }); + return src_path.root_dir.handle.updateFile(src_path.sub_path, std.fs.cwd(), dest_path, .{}) catch |err| { + return s.fail("unable to update file from '{}' to '{s}': {s}", .{ + src_path, dest_path, @errorName(err), + }); + }; +} + +/// Wrapper around `std.fs.Dir.makePathStatus` that handles verbose and error output. +pub fn installDir(s: *Step, dest_path: []const u8) !std.fs.Dir.MakePathStatus { + const b = s.owner; + try handleVerbose(b, null, &.{ "install", "-d", dest_path }); + return std.fs.cwd().makePathStatus(dest_path) catch |err| { + return s.fail("unable to create dir '{s}': {s}", .{ + dest_path, @errorName(err), + }); + }; +} + fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?Path { const b = s.owner; const arena = b.allocator; @@ -714,8 +737,44 @@ pub fn allocPrintCmd2( opt_env: ?*const std.process.EnvMap, argv: []const []const u8, ) Allocator.Error![]u8 { + const shell = struct { + fn escape(writer: anytype, string: []const u8, is_argv0: bool) !void { + for (string) |c| { + if (switch (c) { + else => true, + '%', '+'...':', '@'...'Z', '_', 'a'...'z' => false, + '=' => is_argv0, + }) break; + } else return writer.writeAll(string); + + try writer.writeByte('"'); + for (string) |c| { + if (switch (c) { + std.ascii.control_code.nul => break, + '!', '"', '$', '\\', '`' => true, + else => !std.ascii.isPrint(c), + }) try writer.writeByte('\\'); + switch (c) { + std.ascii.control_code.nul => unreachable, + std.ascii.control_code.bel => try writer.writeByte('a'), + std.ascii.control_code.bs => try writer.writeByte('b'), + std.ascii.control_code.ht => try writer.writeByte('t'), + std.ascii.control_code.lf => try writer.writeByte('n'), + std.ascii.control_code.vt => try writer.writeByte('v'), + std.ascii.control_code.ff => try writer.writeByte('f'), + std.ascii.control_code.cr => try writer.writeByte('r'), + std.ascii.control_code.esc => try writer.writeByte('E'), + ' '...'~' => try writer.writeByte(c), + else => try writer.print("{o:0>3}", .{c}), + } + } + try writer.writeByte('"'); + } + }; + var buf: std.ArrayListUnmanaged(u8) = .empty; - if (opt_cwd) |cwd| try buf.writer(arena).print("cd {s} && ", .{cwd}); + const writer = buf.writer(arena); + if (opt_cwd) |cwd| try writer.print("cd {s} && ", .{cwd}); if (opt_env) |env| { const process_env_map = std.process.getEnvMap(arena) catch std.process.EnvMap.init(arena); var it = env.iterator(); @@ -725,11 +784,15 @@ pub fn allocPrintCmd2( if (process_env_map.get(key)) |process_value| { if (std.mem.eql(u8, value, process_value)) continue; } - try buf.writer(arena).print("{s}={s} ", .{ key, value }); + try writer.print("{s}=", .{key}); + try shell.escape(writer, value, false); + try writer.writeByte(' '); } } - for (argv) |arg| { - try buf.writer(arena).print("{s} ", .{arg}); + try shell.escape(writer, argv[0], true); + for (argv[1..]) |arg| { + try writer.writeByte(' '); + try shell.escape(writer, arg, false); } return buf.toOwnedSlice(arena); } diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig index fa84ac5e6e48..e10840db756a 100644 --- a/lib/std/Build/Step/Compile.zig +++ b/lib/std/Build/Step/Compile.zig @@ -668,6 +668,7 @@ pub fn producesPdbFile(compile: *Compile) bool { else => return false, } if (target.ofmt == .c) return false; + if (compile.use_llvm == false) return false; if (compile.root_module.strip == true or (compile.root_module.strip == null and compile.root_module.optimize == .ReleaseSmall)) { diff --git a/lib/std/Build/Step/InstallArtifact.zig b/lib/std/Build/Step/InstallArtifact.zig index 9d8cb92bb722..6a5b834caeb8 100644 --- a/lib/std/Build/Step/InstallArtifact.zig +++ b/lib/std/Build/Step/InstallArtifact.zig @@ -119,18 +119,12 @@ fn make(step: *Step, options: Step.MakeOptions) !void { _ = options; const install_artifact: *InstallArtifact = @fieldParentPtr("step", step); const b = step.owner; - const cwd = fs.cwd(); var all_cached = true; if (install_artifact.dest_dir) |dest_dir| { const full_dest_path = b.getInstallPath(dest_dir, install_artifact.dest_sub_path); - const src_path = install_artifact.emitted_bin.?.getPath3(b, step); - const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_dest_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_path.sub_path, full_dest_path, @errorName(err), - }); - }; + const p = try step.installFile(install_artifact.emitted_bin.?, full_dest_path); all_cached = all_cached and p == .fresh; if (install_artifact.dylib_symlinks) |dls| { @@ -141,48 +135,28 @@ fn make(step: *Step, options: Step.MakeOptions) !void { } if (install_artifact.implib_dir) |implib_dir| { - const src_path = install_artifact.emitted_implib.?.getPath3(b, step); - const full_implib_path = b.getInstallPath(implib_dir, fs.path.basename(src_path.sub_path)); - const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_implib_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_path.sub_path, full_implib_path, @errorName(err), - }); - }; + const full_implib_path = b.getInstallPath(implib_dir, install_artifact.emitted_implib.?.basename(b, step)); + const p = try step.installFile(install_artifact.emitted_implib.?, full_implib_path); all_cached = all_cached and p == .fresh; } if (install_artifact.pdb_dir) |pdb_dir| { - const src_path = install_artifact.emitted_pdb.?.getPath3(b, step); - const full_pdb_path = b.getInstallPath(pdb_dir, fs.path.basename(src_path.sub_path)); - const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_pdb_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_path.sub_path, full_pdb_path, @errorName(err), - }); - }; + const full_pdb_path = b.getInstallPath(pdb_dir, install_artifact.emitted_pdb.?.basename(b, step)); + const p = try step.installFile(install_artifact.emitted_pdb.?, full_pdb_path); all_cached = all_cached and p == .fresh; } if (install_artifact.h_dir) |h_dir| { if (install_artifact.emitted_h) |emitted_h| { - const src_path = emitted_h.getPath3(b, step); - const full_h_path = b.getInstallPath(h_dir, fs.path.basename(src_path.sub_path)); - const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_h_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_path.sub_path, full_h_path, @errorName(err), - }); - }; + const full_h_path = b.getInstallPath(h_dir, emitted_h.basename(b, step)); + const p = try step.installFile(emitted_h, full_h_path); all_cached = all_cached and p == .fresh; } for (install_artifact.artifact.installed_headers.items) |installation| switch (installation) { .file => |file| { - const src_path = file.source.getPath3(b, step); const full_h_path = b.getInstallPath(h_dir, file.dest_rel_path); - const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_h_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_path.sub_path, full_h_path, @errorName(err), - }); - }; + const p = try step.installFile(file.source, full_h_path); all_cached = all_cached and p == .fresh; }, .directory => |dir| { @@ -209,16 +183,15 @@ fn make(step: *Step, options: Step.MakeOptions) !void { } } - const src_entry_path = src_dir_path.join(b.allocator, entry.path) catch @panic("OOM"); const full_dest_path = b.pathJoin(&.{ full_h_prefix, entry.path }); switch (entry.kind) { - .directory => try cwd.makePath(full_dest_path), + .directory => { + try Step.handleVerbose(b, null, &.{ "install", "-d", full_dest_path }); + const p = try step.installDir(full_dest_path); + all_cached = all_cached and p == .existed; + }, .file => { - const p = fs.Dir.updateFile(src_entry_path.root_dir.handle, src_entry_path.sub_path, cwd, full_dest_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - src_entry_path.sub_path, full_dest_path, @errorName(err), - }); - }; + const p = try step.installFile(try dir.source.join(b.allocator, entry.path), full_dest_path); all_cached = all_cached and p == .fresh; }, else => continue, diff --git a/lib/std/Build/Step/InstallDir.zig b/lib/std/Build/Step/InstallDir.zig index 4d4ff78cfc75..ece1184d8fe2 100644 --- a/lib/std/Build/Step/InstallDir.zig +++ b/lib/std/Build/Step/InstallDir.zig @@ -74,31 +74,23 @@ fn make(step: *Step, options: Step.MakeOptions) !void { var all_cached = true; next_entry: while (try it.next()) |entry| { for (install_dir.options.exclude_extensions) |ext| { - if (mem.endsWith(u8, entry.path, ext)) { - continue :next_entry; - } + if (mem.endsWith(u8, entry.path, ext)) continue :next_entry; } if (install_dir.options.include_extensions) |incs| { - var found = false; for (incs) |inc| { - if (mem.endsWith(u8, entry.path, inc)) { - found = true; - break; - } + if (mem.endsWith(u8, entry.path, inc)) break; + } else { + continue :next_entry; } - if (!found) continue :next_entry; } - // relative to src build root - const src_sub_path = try src_dir_path.join(arena, entry.path); + const src_path = try install_dir.options.source_dir.join(b.allocator, entry.path); const dest_path = b.pathJoin(&.{ dest_prefix, entry.path }); - const cwd = fs.cwd(); - switch (entry.kind) { .directory => { - if (need_derived_inputs) try step.addDirectoryWatchInputFromPath(src_sub_path); - try cwd.makePath(dest_path); - // TODO: set result_cached=false if the directory did not already exist. + if (need_derived_inputs) _ = try step.addDirectoryWatchInput(src_path); + const p = try step.installDir(dest_path); + all_cached = all_cached and p == .existed; }, .file => { for (install_dir.options.blank_extensions) |ext| { @@ -108,18 +100,8 @@ fn make(step: *Step, options: Step.MakeOptions) !void { } } - const prev_status = fs.Dir.updateFile( - src_sub_path.root_dir.handle, - src_sub_path.sub_path, - cwd, - dest_path, - .{}, - ) catch |err| { - return step.fail("unable to update file from '{}' to '{s}': {s}", .{ - src_sub_path, dest_path, @errorName(err), - }); - }; - all_cached = all_cached and prev_status == .fresh; + const p = try step.installFile(src_path, dest_path); + all_cached = all_cached and p == .fresh; }, else => continue, } diff --git a/lib/std/Build/Step/InstallFile.zig b/lib/std/Build/Step/InstallFile.zig index fb1c0ffc3405..10adb4754db3 100644 --- a/lib/std/Build/Step/InstallFile.zig +++ b/lib/std/Build/Step/InstallFile.zig @@ -41,13 +41,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void { const install_file: *InstallFile = @fieldParentPtr("step", step); try step.singleUnchangingWatchInput(install_file.source); - const full_src_path = install_file.source.getPath2(b, step); const full_dest_path = b.getInstallPath(install_file.dir, install_file.dest_rel_path); - const cwd = std.fs.cwd(); - const prev = std.fs.Dir.updateFile(cwd, full_src_path, cwd, full_dest_path, .{}) catch |err| { - return step.fail("unable to update file from '{s}' to '{s}': {s}", .{ - full_src_path, full_dest_path, @errorName(err), - }); - }; - step.result_cached = prev == .fresh; + const p = try step.installFile(install_file.source, full_dest_path); + step.result_cached = p == .fresh; } diff --git a/lib/std/Build/Step/ObjCopy.zig b/lib/std/Build/Step/ObjCopy.zig index 9b2c2d596ff5..74f871d2fc95 100644 --- a/lib/std/Build/Step/ObjCopy.zig +++ b/lib/std/Build/Step/ObjCopy.zig @@ -209,7 +209,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void { } if (objcopy.add_section) |section| { try argv.append("--add-section"); - try argv.appendSlice(&.{b.fmt("{s}={s}", .{ section.section_name, section.file_path.getPath(b) })}); + try argv.appendSlice(&.{b.fmt("{s}={s}", .{ section.section_name, section.file_path.getPath2(b, step) })}); } if (objcopy.set_section_alignment) |set_align| { try argv.append("--set-section-alignment"); diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig index eb5ea1c60744..af7f0ee1a92c 100644 --- a/lib/std/Build/Step/Run.zig +++ b/lib/std/Build/Step/Run.zig @@ -456,11 +456,28 @@ pub fn addPathDir(run: *Run, search_path: []const u8) void { const b = run.step.owner; const env_map = getEnvMapInternal(run); - const key = "PATH"; + const use_wine = b.enable_wine and b.graph.host.result.os.tag != .windows and use_wine: switch (run.argv.items[0]) { + .artifact => |p| p.artifact.rootModuleTarget().os.tag == .windows, + .lazy_path => |p| { + switch (p.lazy_path) { + .generated => |g| if (g.file.step.cast(Step.Compile)) |cs| break :use_wine cs.rootModuleTarget().os.tag == .windows, + else => {}, + } + break :use_wine std.mem.endsWith(u8, p.lazy_path.basename(b, &run.step), ".exe"); + }, + .decorated_directory => false, + .bytes => |bytes| std.mem.endsWith(u8, bytes, ".exe"), + .output_file, .output_directory => false, + }; + const key = if (use_wine) "WINEPATH" else "PATH"; const prev_path = env_map.get(key); if (prev_path) |pp| { - const new_path = b.fmt("{s}" ++ [1]u8{fs.path.delimiter} ++ "{s}", .{ pp, search_path }); + const new_path = b.fmt("{s}{c}{s}", .{ + pp, + if (use_wine) fs.path.delimiter_windows else fs.path.delimiter, + search_path, + }); env_map.put(key, new_path) catch @panic("OOM"); } else { env_map.put(key, b.dupePath(search_path)) catch @panic("OOM"); @@ -866,7 +883,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void { try runCommand(run, argv_list.items, has_side_effects, tmp_dir_path, prog_node, null); const dep_file_dir = std.fs.cwd(); - const dep_file_basename = dep_output_file.generated_file.getPath(); + const dep_file_basename = dep_output_file.generated_file.getPath2(b, step); if (has_side_effects) try man.addDepFile(dep_file_dir, dep_file_basename) else diff --git a/lib/std/fs/Dir.zig b/lib/std/fs/Dir.zig index 90c46740ca25..5d88a2de15c9 100644 --- a/lib/std/fs/Dir.zig +++ b/lib/std/fs/Dir.zig @@ -1146,6 +1146,7 @@ pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) MakeError!void { /// On Windows, `sub_path` should be encoded as [WTF-8](https://simonsapin.github.io/wtf-8/). /// On WASI, `sub_path` should be encoded as valid UTF-8. /// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding. +/// Fails on an empty path with `error.BadPathName` as that is not a path that can be created. /// /// Paths containing `..` components are handled differently depending on the platform: /// - On Windows, `..` are resolved before the path is passed to NtCreateFile, meaning @@ -1155,10 +1156,19 @@ pub fn makeDirW(self: Dir, sub_path: [*:0]const u16) MakeError!void { /// meaning a `sub_path` like "first/../second" will create both a `./first` /// and a `./second` directory. pub fn makePath(self: Dir, sub_path: []const u8) (MakeError || StatFileError)!void { + _ = try self.makePathStatus(sub_path); +} + +pub const MakePathStatus = enum { existed, created }; +/// Same as `makePath` except returns whether the path already existed or was successfully created. +pub fn makePathStatus(self: Dir, sub_path: []const u8) (MakeError || StatFileError)!MakePathStatus { var it = try fs.path.componentIterator(sub_path); - var component = it.last() orelse return; + var status: MakePathStatus = .existed; + var component = it.last() orelse return error.BadPathName; while (true) { - self.makeDir(component.path) catch |err| switch (err) { + if (self.makeDir(component.path)) |_| { + status = .created; + } else |err| switch (err) { error.PathAlreadyExists => { // stat the file and return an error if it's not a directory // this is important because otherwise a dangling symlink @@ -1177,8 +1187,8 @@ pub fn makePath(self: Dir, sub_path: []const u8) (MakeError || StatFileError)!vo continue; }, else => |e| return e, - }; - component = it.next() orelse return; + } + component = it.next() orelse return status; } } diff --git a/lib/std/fs/path.zig b/lib/std/fs/path.zig index b2f95a937f05..159eb0256494 100644 --- a/lib/std/fs/path.zig +++ b/lib/std/fs/path.zig @@ -27,8 +27,8 @@ const fs = std.fs; const process = std.process; const native_os = builtin.target.os.tag; -pub const sep_windows = '\\'; -pub const sep_posix = '/'; +pub const sep_windows: u8 = '\\'; +pub const sep_posix: u8 = '/'; pub const sep = switch (native_os) { .windows, .uefi => sep_windows, else => sep_posix, @@ -41,8 +41,8 @@ pub const sep_str = switch (native_os) { else => sep_str_posix, }; -pub const delimiter_windows = ';'; -pub const delimiter_posix = ':'; +pub const delimiter_windows: u8 = ';'; +pub const delimiter_posix: u8 = ':'; pub const delimiter = if (native_os == .windows) delimiter_windows else delimiter_posix; /// Returns if the given byte is a valid path separator From 917640810e7f3e18daff9e75b5ecefe761a1896c Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 13 Jun 2025 04:46:30 -0400 Subject: [PATCH 3/6] Target: pass and use locals by pointer instead of by value This struct is larger than 256 bytes and code that copies it consistently shows up in profiles of the compiler. --- build.zig | 2 +- lib/compiler/resinator/main.zig | 4 +- lib/compiler_rt/divmodei4.zig | 4 +- lib/compiler_rt/fixdfei.zig | 2 +- lib/compiler_rt/fixhfei.zig | 2 +- lib/compiler_rt/fixsfei.zig | 2 +- lib/compiler_rt/fixtfei.zig | 2 +- lib/compiler_rt/fixunsdfei.zig | 2 +- lib/compiler_rt/fixunshfei.zig | 2 +- lib/compiler_rt/fixunssfei.zig | 2 +- lib/compiler_rt/fixunstfei.zig | 2 +- lib/compiler_rt/fixunsxfei.zig | 2 +- lib/compiler_rt/fixxfei.zig | 2 +- lib/compiler_rt/floateidf.zig | 2 +- lib/compiler_rt/floateihf.zig | 2 +- lib/compiler_rt/floateisf.zig | 2 +- lib/compiler_rt/floateitf.zig | 2 +- lib/compiler_rt/floateixf.zig | 2 +- lib/compiler_rt/floatuneidf.zig | 2 +- lib/compiler_rt/floatuneihf.zig | 2 +- lib/compiler_rt/floatuneisf.zig | 2 +- lib/compiler_rt/floatuneitf.zig | 2 +- lib/compiler_rt/floatuneixf.zig | 2 +- lib/compiler_rt/udivmodei4.zig | 4 +- lib/std/Build/Fuzz/WebServer.zig | 4 +- lib/std/Build/Module.zig | 8 +-- lib/std/Build/Step/Compile.zig | 4 +- lib/std/Build/Step/Run.zig | 2 +- lib/std/Target.zig | 52 +++++++-------- lib/std/Target/Query.zig | 2 +- lib/std/debug/Dwarf/abi.zig | 2 +- lib/std/debug/SelfInfo.zig | 6 +- lib/std/zig.zig | 2 +- lib/std/zig/LibCDirs.zig | 8 +-- lib/std/zig/LibCInstallation.zig | 8 +-- lib/std/zig/llvm/Builder.zig | 2 +- lib/std/zig/system.zig | 2 +- lib/std/zig/system/NativePaths.zig | 2 +- lib/std/zig/system/darwin.zig | 2 +- lib/std/zig/target.zig | 12 ++-- src/Compilation.zig | 40 ++++++----- src/Compilation/Config.zig | 2 +- src/Package/Module.zig | 6 +- src/Sema.zig | 8 +-- src/Type.zig | 6 +- src/Zcu.zig | 6 +- src/Zcu/PerThread.zig | 2 +- src/arch/aarch64/CodeGen.zig | 4 +- src/arch/arm/CodeGen.zig | 2 +- src/arch/riscv64/CodeGen.zig | 10 +-- src/arch/sparc64/CodeGen.zig | 2 +- src/arch/wasm/CodeGen.zig | 30 ++++----- src/arch/x86_64/CodeGen.zig | 102 ++++++++++++++--------------- src/arch/x86_64/Emit.zig | 4 +- src/arch/x86_64/abi.zig | 2 +- src/codegen.zig | 22 +++---- src/codegen/c.zig | 12 ++-- src/codegen/c/Type.zig | 14 ++-- src/codegen/llvm.zig | 76 +++++++++++---------- src/codegen/spirv.zig | 2 +- src/codegen/spirv/Module.zig | 4 +- src/libs/freebsd.zig | 4 +- src/libs/glibc.zig | 6 +- src/libs/libcxx.zig | 4 +- src/libs/libtsan.zig | 2 +- src/libs/libunwind.zig | 2 +- src/libs/mingw.zig | 6 +- src/libs/musl.zig | 2 +- src/libs/netbsd.zig | 4 +- src/link.zig | 10 +-- src/link/C.zig | 4 +- src/link/Coff.zig | 8 +-- src/link/Dwarf.zig | 8 +-- src/link/Elf.zig | 12 ++-- src/link/Elf/Object.zig | 10 +-- src/link/Elf/SharedObject.zig | 2 +- src/link/Elf/ZigObject.zig | 2 +- src/link/Goff.zig | 4 +- src/link/Lld.zig | 16 ++--- src/link/MachO.zig | 8 +-- src/link/MachO/ZigObject.zig | 2 +- src/link/Plan9.zig | 10 +-- src/link/SpirV.zig | 2 +- src/link/Wasm.zig | 2 +- src/link/Xcoff.zig | 4 +- src/main.zig | 14 ++-- src/print_targets.zig | 2 +- src/target.zig | 87 ++++++++++++------------ test/link/macho.zig | 2 +- test/src/Cases.zig | 4 +- test/src/Debugger.zig | 8 +-- test/src/StackTrace.zig | 4 +- test/standalone/ios/build.zig | 2 +- test/tests.zig | 8 +-- tools/doctest.zig | 4 +- tools/incr-check.zig | 4 +- 96 files changed, 400 insertions(+), 401 deletions(-) diff --git a/build.zig b/build.zig index c6c624aaee04..b836037a3daf 100644 --- a/build.zig +++ b/build.zig @@ -759,7 +759,7 @@ fn addCmakeCfgOptionsToExe( use_zig_libcxx: bool, ) !void { const mod = exe.root_module; - const target = mod.resolved_target.?.result; + const target = &mod.resolved_target.?.result; if (target.os.tag.isDarwin()) { // useful for package maintainers diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig index 3266b7921fd8..a96289ceecf0 100644 --- a/lib/compiler/resinator/main.zig +++ b/lib/compiler/resinator/main.zig @@ -525,7 +525,7 @@ fn getIncludePaths(arena: std.mem.Allocator, auto_includes_option: cli.Options.A }; const target = std.zig.resolveTargetQueryOrFatal(target_query); const is_native_abi = target_query.isNativeAbi(); - const detected_libc = std.zig.LibCDirs.detect(arena, zig_lib_dir, target, is_native_abi, true, null) catch { + const detected_libc = std.zig.LibCDirs.detect(arena, zig_lib_dir, &target, is_native_abi, true, null) catch { if (includes == .any) { // fall back to mingw includes = .gnu; @@ -550,7 +550,7 @@ fn getIncludePaths(arena: std.mem.Allocator, auto_includes_option: cli.Options.A }; const target = std.zig.resolveTargetQueryOrFatal(target_query); const is_native_abi = target_query.isNativeAbi(); - const detected_libc = std.zig.LibCDirs.detect(arena, zig_lib_dir, target, is_native_abi, true, null) catch |err| switch (err) { + const detected_libc = std.zig.LibCDirs.detect(arena, zig_lib_dir, &target, is_native_abi, true, null) catch |err| switch (err) { error.OutOfMemory => |e| return e, else => return error.MingwIncludesNotFound, }; diff --git a/lib/compiler_rt/divmodei4.zig b/lib/compiler_rt/divmodei4.zig index 9e5e4333b999..3f12e8697d27 100644 --- a/lib/compiler_rt/divmodei4.zig +++ b/lib/compiler_rt/divmodei4.zig @@ -35,7 +35,7 @@ fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void { pub fn __divei4(q_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void { @setRuntimeSafety(builtin.is_test); - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size])); const u: []u32 = @ptrCast(@alignCast(u_p[0..byte_size])); const v: []u32 = @ptrCast(@alignCast(v_p[0..byte_size])); @@ -44,7 +44,7 @@ pub fn __divei4(q_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) vo pub fn __modei4(r_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void { @setRuntimeSafety(builtin.is_test); - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size])); const u: []u32 = @ptrCast(@alignCast(u_p[0..byte_size])); const v: []u32 = @ptrCast(@alignCast(v_p[0..byte_size])); diff --git a/lib/compiler_rt/fixdfei.zig b/lib/compiler_rt/fixdfei.zig index 95189b0f7b41..31c7994c58c5 100644 --- a/lib/compiler_rt/fixdfei.zig +++ b/lib/compiler_rt/fixdfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixhfei.zig b/lib/compiler_rt/fixhfei.zig index c4532f18c043..c7f30055c561 100644 --- a/lib/compiler_rt/fixhfei.zig +++ b/lib/compiler_rt/fixhfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixhfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixsfei.zig b/lib/compiler_rt/fixsfei.zig index 8182ca055108..c72e002fb1ff 100644 --- a/lib/compiler_rt/fixsfei.zig +++ b/lib/compiler_rt/fixsfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixsfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixtfei.zig b/lib/compiler_rt/fixtfei.zig index 02a2c164a624..8daf3754f77e 100644 --- a/lib/compiler_rt/fixtfei.zig +++ b/lib/compiler_rt/fixtfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixtfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixunsdfei.zig b/lib/compiler_rt/fixunsdfei.zig index a88c344bc66f..886feab66aa5 100644 --- a/lib/compiler_rt/fixunsdfei.zig +++ b/lib/compiler_rt/fixunsdfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixunshfei.zig b/lib/compiler_rt/fixunshfei.zig index 056d2faaf74a..788605a6868e 100644 --- a/lib/compiler_rt/fixunshfei.zig +++ b/lib/compiler_rt/fixunshfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixunssfei.zig b/lib/compiler_rt/fixunssfei.zig index 179e395de077..bb89fc283dea 100644 --- a/lib/compiler_rt/fixunssfei.zig +++ b/lib/compiler_rt/fixunssfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixunstfei.zig b/lib/compiler_rt/fixunstfei.zig index b69fb31ab600..997a100afacc 100644 --- a/lib/compiler_rt/fixunstfei.zig +++ b/lib/compiler_rt/fixunstfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixunsxfei.zig b/lib/compiler_rt/fixunsxfei.zig index ca1bae9a805a..88c7f1824388 100644 --- a/lib/compiler_rt/fixunsxfei.zig +++ b/lib/compiler_rt/fixunsxfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/fixxfei.zig b/lib/compiler_rt/fixxfei.zig index 5efe7da7e952..6f28153a6634 100644 --- a/lib/compiler_rt/fixxfei.zig +++ b/lib/compiler_rt/fixxfei.zig @@ -10,6 +10,6 @@ comptime { } pub fn __fixxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a); } diff --git a/lib/compiler_rt/floateidf.zig b/lib/compiler_rt/floateidf.zig index c540cc1d1c40..96411ae878cc 100644 --- a/lib/compiler_rt/floateidf.zig +++ b/lib/compiler_rt/floateidf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f64, .signed, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floateihf.zig b/lib/compiler_rt/floateihf.zig index b9544cc9b021..ac9fd355c7f6 100644 --- a/lib/compiler_rt/floateihf.zig +++ b/lib/compiler_rt/floateihf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floateihf(a: [*]const u8, bits: usize) callconv(.c) f16 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f16, .signed, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floateisf.zig b/lib/compiler_rt/floateisf.zig index 6420016d00de..f53b75643f73 100644 --- a/lib/compiler_rt/floateisf.zig +++ b/lib/compiler_rt/floateisf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floateisf(a: [*]const u8, bits: usize) callconv(.c) f32 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f32, .signed, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floateitf.zig b/lib/compiler_rt/floateitf.zig index 6dfaac295574..3e07c6becbf8 100644 --- a/lib/compiler_rt/floateitf.zig +++ b/lib/compiler_rt/floateitf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floateitf(a: [*]const u8, bits: usize) callconv(.c) f128 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f128, .signed, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floateixf.zig b/lib/compiler_rt/floateixf.zig index 4c76e8b12f1a..65585e2ed30c 100644 --- a/lib/compiler_rt/floateixf.zig +++ b/lib/compiler_rt/floateixf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f80, .signed, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floatuneidf.zig b/lib/compiler_rt/floatuneidf.zig index e47ae0309ba6..c7b1e032ea71 100644 --- a/lib/compiler_rt/floatuneidf.zig +++ b/lib/compiler_rt/floatuneidf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floatuneidf(a: [*]const u8, bits: usize) callconv(.c) f64 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f64, .unsigned, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floatuneihf.zig b/lib/compiler_rt/floatuneihf.zig index cc8962161cdd..00c53a19197c 100644 --- a/lib/compiler_rt/floatuneihf.zig +++ b/lib/compiler_rt/floatuneihf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floatuneihf(a: [*]const u8, bits: usize) callconv(.c) f16 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f16, .unsigned, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floatuneisf.zig b/lib/compiler_rt/floatuneisf.zig index 325b0afe7088..4acb0fa7b234 100644 --- a/lib/compiler_rt/floatuneisf.zig +++ b/lib/compiler_rt/floatuneisf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floatuneisf(a: [*]const u8, bits: usize) callconv(.c) f32 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f32, .unsigned, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floatuneitf.zig b/lib/compiler_rt/floatuneitf.zig index 727d301f7bf3..323f44611d23 100644 --- a/lib/compiler_rt/floatuneitf.zig +++ b/lib/compiler_rt/floatuneitf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f128, .unsigned, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/floatuneixf.zig b/lib/compiler_rt/floatuneixf.zig index adfa8aa5ee1c..12157d20a343 100644 --- a/lib/compiler_rt/floatuneixf.zig +++ b/lib/compiler_rt/floatuneixf.zig @@ -10,6 +10,6 @@ comptime { } pub fn __floatuneixf(a: [*]const u8, bits: usize) callconv(.c) f80 { - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); return floatFromBigInt(f80, .unsigned, @ptrCast(@alignCast(a[0..byte_size]))); } diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig index d84bace9fbac..6d6f6c1b65e1 100644 --- a/lib/compiler_rt/udivmodei4.zig +++ b/lib/compiler_rt/udivmodei4.zig @@ -114,7 +114,7 @@ pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void { pub fn __udivei4(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) callconv(.c) void { @setRuntimeSafety(builtin.is_test); - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); const q: []u32 = @ptrCast(@alignCast(q_p[0..byte_size])); const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size])); const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size])); @@ -123,7 +123,7 @@ pub fn __udivei4(q_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) ca pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) callconv(.c) void { @setRuntimeSafety(builtin.is_test); - const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits)); + const byte_size = std.zig.target.intByteSize(&builtin.target, @intCast(bits)); const r: []u32 = @ptrCast(@alignCast(r_p[0..byte_size])); const u: []const u32 = @ptrCast(@alignCast(u_p[0..byte_size])); const v: []const u32 = @ptrCast(@alignCast(v_p[0..byte_size])); diff --git a/lib/std/Build/Fuzz/WebServer.zig b/lib/std/Build/Fuzz/WebServer.zig index 87cd7a1a1deb..ab44d4e7af6f 100644 --- a/lib/std/Build/Fuzz/WebServer.zig +++ b/lib/std/Build/Fuzz/WebServer.zig @@ -198,10 +198,10 @@ fn serveWasm( const wasm_base_path = try buildWasmBinary(ws, arena, optimize_mode); const bin_name = try std.zig.binNameAlloc(arena, .{ .root_name = fuzzer_bin_name, - .target = std.zig.system.resolveTargetQuery(std.Build.parseTargetQuery(.{ + .target = &(std.zig.system.resolveTargetQuery(std.Build.parseTargetQuery(.{ .arch_os_abi = fuzzer_arch_os_abi, .cpu_features = fuzzer_cpu_features, - }) catch unreachable) catch unreachable, + }) catch unreachable) catch unreachable), .output_mode = .Exe, }); // std.http.Server does not have a sendfile API yet. diff --git a/lib/std/Build/Module.zig b/lib/std/Build/Module.zig index 12b55a8c29e7..d9c098113f1b 100644 --- a/lib/std/Build/Module.zig +++ b/lib/std/Build/Module.zig @@ -655,10 +655,10 @@ fn linkLibraryOrObject(m: *Module, other: *Step.Compile) void { m.include_dirs.append(allocator, .{ .other_step = other }) catch @panic("OOM"); } -fn requireKnownTarget(m: *Module) std.Target { - const resolved_target = m.resolved_target orelse - @panic("this API requires the Module to be created with a known 'target' field"); - return resolved_target.result; +fn requireKnownTarget(m: *Module) *const std.Target { + const resolved_target = &(m.resolved_target orelse + @panic("this API requires the Module to be created with a known 'target' field")); + return &resolved_target.result; } /// Elements of `modules` and `names` are matched one-to-one. diff --git a/lib/std/Build/Step/Compile.zig b/lib/std/Build/Step/Compile.zig index e10840db756a..9352280d9641 100644 --- a/lib/std/Build/Step/Compile.zig +++ b/lib/std/Build/Step/Compile.zig @@ -377,7 +377,7 @@ pub fn create(owner: *std.Build, options: Options) *Compile { const resolved_target = options.root_module.resolved_target orelse @panic("the root Module of a Compile step must be created with a known 'target' field"); - const target = resolved_target.result; + const target = &resolved_target.result; const step_name = owner.fmt("compile {s} {s} {s}", .{ // Avoid the common case of the step name looking like "compile test test". @@ -1866,7 +1866,7 @@ fn outputPath(c: *Compile, out_dir: std.Build.Cache.Path, ea: std.zig.EmitArtifa const arena = c.step.owner.graph.arena; const name = ea.cacheName(arena, .{ .root_name = c.name, - .target = c.root_module.resolved_target.?.result, + .target = &c.root_module.resolved_target.?.result, .output_mode = switch (c.kind) { .lib => .Lib, .obj, .test_obj => .Obj, diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig index af7f0ee1a92c..aa3931ac8c66 100644 --- a/lib/std/Build/Step/Run.zig +++ b/lib/std/Build/Step/Run.zig @@ -1108,7 +1108,7 @@ fn runCommand( const need_cross_libc = exe.is_linking_libc and (root_target.isGnuLibC() or (root_target.isMuslLibC() and exe.linkage == .dynamic)); const other_target = exe.root_module.resolved_target.?.result; - switch (std.zig.system.getExternalExecutor(b.graph.host.result, &other_target, .{ + switch (std.zig.system.getExternalExecutor(&b.graph.host.result, &other_target, .{ .qemu_fixes_dl = need_cross_libc and b.libc_runtimes_dir != null, .link_libc = exe.is_linking_libc, })) { diff --git a/lib/std/Target.zig b/lib/std/Target.zig index 347b3357f594..b31f6c2de91d 100644 --- a/lib/std/Target.zig +++ b/lib/std/Target.zig @@ -1074,7 +1074,7 @@ pub const ObjectFormat = enum { } }; -pub fn toElfMachine(target: Target) std.elf.EM { +pub fn toElfMachine(target: *const Target) std.elf.EM { return switch (target.cpu.arch) { .amdgcn => .AMDGPU, .arc => .ARC_COMPACT, @@ -1115,7 +1115,7 @@ pub fn toElfMachine(target: Target) std.elf.EM { }; } -pub fn toCoffMachine(target: Target) std.coff.MachineType { +pub fn toCoffMachine(target: *const Target) std.coff.MachineType { return switch (target.cpu.arch) { .arm => .ARM, .thumb => .ARMNT, @@ -1999,7 +1999,7 @@ pub const Cpu = struct { } }; -pub fn zigTriple(target: Target, allocator: Allocator) Allocator.Error![]u8 { +pub fn zigTriple(target: *const Target, allocator: Allocator) Allocator.Error![]u8 { return Query.fromTarget(target).zigTriple(allocator); } @@ -2007,7 +2007,7 @@ pub fn hurdTupleSimple(allocator: Allocator, arch: Cpu.Arch, abi: Abi) ![]u8 { return std.fmt.allocPrint(allocator, "{s}-{s}", .{ @tagName(arch), @tagName(abi) }); } -pub fn hurdTuple(target: Target, allocator: Allocator) ![]u8 { +pub fn hurdTuple(target: *const Target, allocator: Allocator) ![]u8 { return hurdTupleSimple(allocator, target.cpu.arch, target.abi); } @@ -2015,63 +2015,63 @@ pub fn linuxTripleSimple(allocator: Allocator, arch: Cpu.Arch, os_tag: Os.Tag, a return std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{ @tagName(arch), @tagName(os_tag), @tagName(abi) }); } -pub fn linuxTriple(target: Target, allocator: Allocator) ![]u8 { +pub fn linuxTriple(target: *const Target, allocator: Allocator) ![]u8 { return linuxTripleSimple(allocator, target.cpu.arch, target.os.tag, target.abi); } -pub fn exeFileExt(target: Target) [:0]const u8 { +pub fn exeFileExt(target: *const Target) [:0]const u8 { return target.os.tag.exeFileExt(target.cpu.arch); } -pub fn staticLibSuffix(target: Target) [:0]const u8 { +pub fn staticLibSuffix(target: *const Target) [:0]const u8 { return target.os.tag.staticLibSuffix(target.abi); } -pub fn dynamicLibSuffix(target: Target) [:0]const u8 { +pub fn dynamicLibSuffix(target: *const Target) [:0]const u8 { return target.os.tag.dynamicLibSuffix(); } -pub fn libPrefix(target: Target) [:0]const u8 { +pub fn libPrefix(target: *const Target) [:0]const u8 { return target.os.tag.libPrefix(target.abi); } -pub inline fn isMinGW(target: Target) bool { +pub inline fn isMinGW(target: *const Target) bool { return target.os.tag == .windows and target.abi.isGnu(); } -pub inline fn isGnuLibC(target: Target) bool { +pub inline fn isGnuLibC(target: *const Target) bool { return switch (target.os.tag) { .hurd, .linux => target.abi.isGnu(), else => false, }; } -pub inline fn isMuslLibC(target: Target) bool { +pub inline fn isMuslLibC(target: *const Target) bool { return target.os.tag == .linux and target.abi.isMusl(); } -pub inline fn isDarwinLibC(target: Target) bool { +pub inline fn isDarwinLibC(target: *const Target) bool { return switch (target.abi) { .none, .macabi, .simulator => target.os.tag.isDarwin(), else => false, }; } -pub inline fn isFreeBSDLibC(target: Target) bool { +pub inline fn isFreeBSDLibC(target: *const Target) bool { return switch (target.abi) { .none, .eabihf => target.os.tag == .freebsd, else => false, }; } -pub inline fn isNetBSDLibC(target: Target) bool { +pub inline fn isNetBSDLibC(target: *const Target) bool { return switch (target.abi) { .none, .eabi, .eabihf => target.os.tag == .netbsd, else => false, }; } -pub inline fn isWasiLibC(target: Target) bool { +pub inline fn isWasiLibC(target: *const Target) bool { return target.os.tag == .wasi and target.abi.isMusl(); } @@ -2576,7 +2576,7 @@ pub const DynamicLinker = struct { } }; -pub fn standardDynamicLinkerPath(target: Target) DynamicLinker { +pub fn standardDynamicLinkerPath(target: *const Target) DynamicLinker { return DynamicLinker.standard(target.cpu, target.os, target.abi); } @@ -2645,11 +2645,11 @@ pub fn ptrBitWidth_arch_abi(cpu_arch: Cpu.Arch, abi: Abi) u16 { }; } -pub fn ptrBitWidth(target: Target) u16 { +pub fn ptrBitWidth(target: *const Target) u16 { return ptrBitWidth_cpu_abi(target.cpu, target.abi); } -pub fn stackAlignment(target: Target) u16 { +pub fn stackAlignment(target: *const Target) u16 { // Overrides for when the stack alignment is not equal to the pointer width. switch (target.cpu.arch) { .m68k, @@ -2697,7 +2697,7 @@ pub fn stackAlignment(target: Target) u16 { /// Default signedness of `char` for the native C compiler for this target /// Note that char signedness is implementation-defined and many compilers provide /// an option to override the default signedness e.g. GCC's -funsigned-char / -fsigned-char -pub fn cCharSignedness(target: Target) std.builtin.Signedness { +pub fn cCharSignedness(target: *const Target) std.builtin.Signedness { if (target.os.tag.isDarwin() or target.os.tag == .windows or target.os.tag == .uefi) return .signed; return switch (target.cpu.arch) { @@ -2740,7 +2740,7 @@ pub const CType = enum { longdouble, }; -pub fn cTypeByteSize(t: Target, c_type: CType) u16 { +pub fn cTypeByteSize(t: *const Target, c_type: CType) u16 { return switch (c_type) { .char, .short, @@ -2766,7 +2766,7 @@ pub fn cTypeByteSize(t: Target, c_type: CType) u16 { }; } -pub fn cTypeBitSize(target: Target, c_type: CType) u16 { +pub fn cTypeBitSize(target: *const Target, c_type: CType) u16 { switch (target.os.tag) { .freestanding, .other => switch (target.cpu.arch) { .msp430 => switch (c_type) { @@ -3077,7 +3077,7 @@ pub fn cTypeBitSize(target: Target, c_type: CType) u16 { } } -pub fn cTypeAlignment(target: Target, c_type: CType) u16 { +pub fn cTypeAlignment(target: *const Target, c_type: CType) u16 { // Overrides for unusual alignments switch (target.cpu.arch) { .avr => return 1, @@ -3172,7 +3172,7 @@ pub fn cTypeAlignment(target: Target, c_type: CType) u16 { ); } -pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 { +pub fn cTypePreferredAlignment(target: *const Target, c_type: CType) u16 { // Overrides for unusual alignments switch (target.cpu.arch) { .arc => switch (c_type) { @@ -3265,7 +3265,7 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 { ); } -pub fn cMaxIntAlignment(target: std.Target) u16 { +pub fn cMaxIntAlignment(target: *const Target) u16 { return switch (target.cpu.arch) { .avr => 1, @@ -3328,7 +3328,7 @@ pub fn cMaxIntAlignment(target: std.Target) u16 { }; } -pub fn cCallingConvention(target: Target) ?std.builtin.CallingConvention { +pub fn cCallingConvention(target: *const Target) ?std.builtin.CallingConvention { return switch (target.cpu.arch) { .x86_64 => switch (target.os.tag) { .windows, .uefi => .{ .x86_64_win = .{} }, diff --git a/lib/std/Target/Query.zig b/lib/std/Target/Query.zig index 478c4758f990..e453b70e5cfe 100644 --- a/lib/std/Target/Query.zig +++ b/lib/std/Target/Query.zig @@ -94,7 +94,7 @@ pub const OsVersion = union(enum) { pub const SemanticVersion = std.SemanticVersion; -pub fn fromTarget(target: Target) Query { +pub fn fromTarget(target: *const Target) Query { var result: Query = .{ .cpu_arch = target.cpu.arch, .cpu_model = .{ .explicit = target.cpu.model }, diff --git a/lib/std/debug/Dwarf/abi.zig b/lib/std/debug/Dwarf/abi.zig index 001e1977f9df..e880b1286369 100644 --- a/lib/std/debug/Dwarf/abi.zig +++ b/lib/std/debug/Dwarf/abi.zig @@ -9,7 +9,7 @@ const Arch = std.Target.Cpu.Arch; /// /// See also `std.debug.SelfInfo.supportsUnwinding` which tells whether the Zig /// standard library has a working implementation of unwinding for this target. -pub fn supportsUnwinding(target: std.Target) bool { +pub fn supportsUnwinding(target: *const std.Target) bool { return switch (target.cpu.arch) { .amdgcn, .nvptx, diff --git a/lib/std/debug/SelfInfo.zig b/lib/std/debug/SelfInfo.zig index 70f3075de7ab..a879309870e5 100644 --- a/lib/std/debug/SelfInfo.zig +++ b/lib/std/debug/SelfInfo.zig @@ -1795,10 +1795,10 @@ fn spRegNum(reg_context: Dwarf.abi.RegisterContext) u8 { const ip_reg_num = Dwarf.abi.ipRegNum(native_arch).?; /// Tells whether unwinding for the host is implemented. -pub const supports_unwinding = supportsUnwinding(builtin.target); +pub const supports_unwinding = supportsUnwinding(&builtin.target); comptime { - if (supports_unwinding) assert(Dwarf.abi.supportsUnwinding(builtin.target)); + if (supports_unwinding) assert(Dwarf.abi.supportsUnwinding(&builtin.target)); } /// Tells whether unwinding for this target is *implemented* here in the Zig @@ -1806,7 +1806,7 @@ comptime { /// /// See also `Dwarf.abi.supportsUnwinding` which tells whether Dwarf supports /// unwinding on that target *in theory*. -pub fn supportsUnwinding(target: std.Target) bool { +pub fn supportsUnwinding(target: *const std.Target) bool { return switch (target.cpu.arch) { .x86 => switch (target.os.tag) { .linux, .netbsd, .solaris, .illumos => true, diff --git a/lib/std/zig.zig b/lib/std/zig.zig index 21f129676623..cf7992baed26 100644 --- a/lib/std/zig.zig +++ b/lib/std/zig.zig @@ -141,7 +141,7 @@ pub fn lineDelta(source: []const u8, start: usize, end: usize) isize { pub const BinNameOptions = struct { root_name: []const u8, - target: std.Target, + target: *const std.Target, output_mode: std.builtin.OutputMode, link_mode: ?std.builtin.LinkMode = null, version: ?std.SemanticVersion = null, diff --git a/lib/std/zig/LibCDirs.zig b/lib/std/zig/LibCDirs.zig index 90d4fa4d5f0f..f742b24c4a05 100644 --- a/lib/std/zig/LibCDirs.zig +++ b/lib/std/zig/LibCDirs.zig @@ -15,7 +15,7 @@ pub const DarwinSdkLayout = enum { pub fn detect( arena: Allocator, zig_lib_dir: []const u8, - target: std.Target, + target: *const std.Target, is_native_abi: bool, link_libc: bool, libc_installation: ?*const LibCInstallation, @@ -88,7 +88,7 @@ pub fn detect( }; } -fn detectFromInstallation(arena: Allocator, target: std.Target, lci: *const LibCInstallation) !LibCDirs { +fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *const LibCInstallation) !LibCDirs { var list = try std.ArrayList([]const u8).initCapacity(arena, 5); var framework_list = std.ArrayList([]const u8).init(arena); @@ -146,7 +146,7 @@ fn detectFromInstallation(arena: Allocator, target: std.Target, lci: *const LibC pub fn detectFromBuilding( arena: Allocator, zig_lib_dir: []const u8, - target: std.Target, + target: *const std.Target, ) !LibCDirs { const s = std.fs.path.sep_str; @@ -224,7 +224,7 @@ pub fn detectFromBuilding( }; } -fn libCGenericName(target: std.Target) [:0]const u8 { +fn libCGenericName(target: *const std.Target) [:0]const u8 { switch (target.os.tag) { .windows => return "mingw", .macos, .ios, .tvos, .watchos, .visionos => return "darwin", diff --git a/lib/std/zig/LibCInstallation.zig b/lib/std/zig/LibCInstallation.zig index 78b35517a662..e2b7cd233ddb 100644 --- a/lib/std/zig/LibCInstallation.zig +++ b/lib/std/zig/LibCInstallation.zig @@ -26,7 +26,7 @@ pub const FindError = error{ pub fn parse( allocator: Allocator, libc_file: []const u8, - target: std.Target, + target: *const std.Target, ) !LibCInstallation { var self: LibCInstallation = .{}; @@ -157,7 +157,7 @@ pub fn render(self: LibCInstallation, out: anytype) !void { pub const FindNativeOptions = struct { allocator: Allocator, - target: std.Target, + target: *const std.Target, /// If enabled, will print human-friendly errors to stderr. verbose: bool = false, @@ -700,7 +700,7 @@ pub const CrtBasenames = struct { crtn: ?[]const u8 = null, pub const GetArgs = struct { - target: std.Target, + target: *const std.Target, link_libc: bool, output_mode: std.builtin.OutputMode, link_mode: std.builtin.LinkMode, @@ -965,7 +965,7 @@ pub fn resolveCrtPaths( lci: LibCInstallation, arena: Allocator, crt_basenames: CrtBasenames, - target: std.Target, + target: *const std.Target, ) error{ OutOfMemory, LibCInstallationMissingCrtDir }!CrtPaths { const crt_dir_path: Path = .{ .root_dir = std.Build.Cache.Directory.cwd(), diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig index 865e1efa6d1c..ff661aa1c7a5 100644 --- a/lib/std/zig/llvm/Builder.zig +++ b/lib/std/zig/llvm/Builder.zig @@ -66,7 +66,7 @@ pub const Options = struct { allocator: Allocator, strip: bool = true, name: []const u8 = &.{}, - target: std.Target = builtin.target, + target: *const std.Target = &builtin.target, triple: []const u8 = &.{}, }; diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig index cf772cb65fde..ba43543ee235 100644 --- a/lib/std/zig/system.zig +++ b/lib/std/zig/system.zig @@ -28,7 +28,7 @@ pub const GetExternalExecutorOptions = struct { /// Return whether or not the given host is capable of running executables of /// the other target. pub fn getExternalExecutor( - host: std.Target, + host: *const std.Target, candidate: *const std.Target, options: GetExternalExecutorOptions, ) Executor { diff --git a/lib/std/zig/system/NativePaths.zig b/lib/std/zig/system/NativePaths.zig index 33b3782f9dca..47af64bc964d 100644 --- a/lib/std/zig/system/NativePaths.zig +++ b/lib/std/zig/system/NativePaths.zig @@ -13,7 +13,7 @@ framework_dirs: std.ArrayListUnmanaged([]const u8) = .empty, rpaths: std.ArrayListUnmanaged([]const u8) = .empty, warnings: std.ArrayListUnmanaged([]const u8) = .empty, -pub fn detect(arena: Allocator, native_target: std.Target) !NativePaths { +pub fn detect(arena: Allocator, native_target: *const std.Target) !NativePaths { var self: NativePaths = .{ .arena = arena }; var is_nix = false; if (process.getEnvVarOwned(arena, "NIX_CFLAGS_COMPILE")) |nix_cflags_compile| { diff --git a/lib/std/zig/system/darwin.zig b/lib/std/zig/system/darwin.zig index f3088cfbfeee..a5f28c2206c7 100644 --- a/lib/std/zig/system/darwin.zig +++ b/lib/std/zig/system/darwin.zig @@ -34,7 +34,7 @@ pub fn isSdkInstalled(allocator: Allocator) bool { /// Caller owns the memory. /// stderr from xcrun is ignored. /// If error.OutOfMemory occurs in Allocator, this function returns null. -pub fn getSdk(allocator: Allocator, target: Target) ?[]const u8 { +pub fn getSdk(allocator: Allocator, target: *const Target) ?[]const u8 { const is_simulator_abi = target.abi == .simulator; const sdk = switch (target.os.tag) { .ios => switch (target.abi) { diff --git a/lib/std/zig/target.zig b/lib/std/zig/target.zig index ec932fe9d9f2..873aa646881e 100644 --- a/lib/std/zig/target.zig +++ b/lib/std/zig/target.zig @@ -116,7 +116,7 @@ pub const freebsd_libc_version: std.SemanticVersion = .{ .major = 14, .minor = 0 /// The version of Zig's bundled NetBSD libc used when linking libc statically. pub const netbsd_libc_version: std.SemanticVersion = .{ .major = 10, .minor = 1, .patch = 0 }; -pub fn canBuildLibC(target: std.Target) bool { +pub fn canBuildLibC(target: *const std.Target) bool { for (available_libcs) |libc| { if (target.cpu.arch == libc.arch and target.os.tag == libc.os and target.abi == libc.abi) { if (libc.os_ver) |libc_os_ver| { @@ -176,7 +176,7 @@ pub fn muslRuntimeTriple( return std.Target.linuxTripleSimple(allocator, arch, .linux, abi); } -pub fn osArchName(target: std.Target) [:0]const u8 { +pub fn osArchName(target: *const std.Target) [:0]const u8 { return switch (target.os.tag) { .linux => switch (target.cpu.arch) { .arm, .armeb, .thumb, .thumbeb => "arm", @@ -276,7 +276,7 @@ pub fn netbsdAbiNameHeaders(abi: std.Target.Abi) [:0]const u8 { }; } -pub fn isLibCLibName(target: std.Target, name: []const u8) bool { +pub fn isLibCLibName(target: *const std.Target, name: []const u8) bool { const ignore_case = target.os.tag.isDarwin() or target.os.tag == .windows; if (eqlIgnoreCase(ignore_case, name, "c")) @@ -453,7 +453,7 @@ pub fn isLibCLibName(target: std.Target, name: []const u8) bool { return false; } -pub fn isLibCxxLibName(target: std.Target, name: []const u8) bool { +pub fn isLibCxxLibName(target: *const std.Target, name: []const u8) bool { const ignore_case = target.os.tag.isDarwin() or target.os.tag == .windows; return eqlIgnoreCase(ignore_case, name, "c++") or @@ -470,11 +470,11 @@ fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool { } } -pub fn intByteSize(target: std.Target, bits: u16) u19 { +pub fn intByteSize(target: *const std.Target, bits: u16) u19 { return std.mem.alignForward(u19, @intCast((@as(u17, bits) + 7) / 8), intAlignment(target, bits)); } -pub fn intAlignment(target: std.Target, bits: u16) u16 { +pub fn intAlignment(target: *const std.Target, bits: u16) u16 { return switch (target.cpu.arch) { .x86 => switch (bits) { 0 => 0, diff --git a/src/Compilation.zig b/src/Compilation.zig index a855b983c99c..402a3f9761b4 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1361,7 +1361,7 @@ pub const cache_helpers = struct { hh: *Cache.HashHelper, resolved_target: Package.Module.ResolvedTarget, ) void { - const target = resolved_target.result; + const target = &resolved_target.result; hh.add(target.cpu.arch); hh.addBytes(target.cpu.model.name); hh.add(target.cpu.features.ints); @@ -1705,7 +1705,7 @@ pub const CreateOptions = struct { assert(opts.cache_mode != .none); return try ea.cacheName(arena, .{ .root_name = opts.root_name, - .target = opts.root_mod.resolved_target.result, + .target = &opts.root_mod.resolved_target.result, .output_mode = opts.config.output_mode, .link_mode = opts.config.link_mode, .version = opts.version, @@ -1772,14 +1772,14 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil } const have_zcu = options.config.have_zcu; + const use_llvm = options.config.use_llvm; + const target = &options.root_mod.resolved_target.result; const comp: *Compilation = comp: { // We put the `Compilation` itself in the arena. Freeing the arena will free the module. // It's initialized later after we prepare the initialization options. const root_name = try arena.dupeZ(u8, options.root_name); - const use_llvm = options.config.use_llvm; - // The "any" values provided by resolved config only account for // explicitly-provided settings. We now make them additionally account // for default setting resolution. @@ -1804,7 +1804,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil const libc_dirs = try std.zig.LibCDirs.detect( arena, options.dirs.zig_lib.path.?, - options.root_mod.resolved_target.result, + target, options.root_mod.resolved_target.is_native_abi, link_libc, options.libc_installation, @@ -1846,7 +1846,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil // approach, since the ubsan runtime uses quite a lot of the standard library // and this reduces unnecessary bloat. const ubsan_rt_strat: RtStrat = s: { - const can_build_ubsan_rt = target_util.canBuildLibUbsanRt(options.root_mod.resolved_target.result); + const can_build_ubsan_rt = target_util.canBuildLibUbsanRt(target); const want_ubsan_rt = options.want_ubsan_rt orelse (can_build_ubsan_rt and any_sanitize_c == .full and is_exe_or_dyn_lib); if (!want_ubsan_rt) break :s .none; if (options.skip_linker_dependencies) break :s .none; @@ -1872,7 +1872,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil if (options.verbose_llvm_cpu_features) { if (options.root_mod.resolved_target.llvm_cpu_features) |cf| print: { - const target = options.root_mod.resolved_target.result; std.debug.lockStdErr(); defer std.debug.unlockStdErr(); const stderr = std.io.getStdErr().writer(); @@ -2244,8 +2243,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil }; errdefer comp.destroy(); - const target = comp.root_mod.resolved_target.result; - const can_build_compiler_rt = target_util.canBuildLibCompilerRt(target, comp.config.use_llvm, build_options.have_llvm); + const can_build_compiler_rt = target_util.canBuildLibCompilerRt(target, use_llvm, build_options.have_llvm); // Add a `CObject` for each `c_source_files`. try comp.c_object_table.ensureTotalCapacity(gpa, options.c_source_files.len); @@ -2344,7 +2342,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil comp.link_task_queue.pending_prelink_tasks += 1; } comp.queued_jobs.glibc_shared_objects = true; - comp.link_task_queue.pending_prelink_tasks += glibc.sharedObjectsCount(&target); + comp.link_task_queue.pending_prelink_tasks += glibc.sharedObjectsCount(target); comp.queued_jobs.glibc_crt_file[@intFromEnum(glibc.CrtFile.libc_nonshared_a)] = true; comp.link_task_queue.pending_prelink_tasks += 1; @@ -2571,8 +2569,8 @@ pub fn clearMiscFailures(comp: *Compilation) void { comp.misc_failures = .{}; } -pub fn getTarget(self: Compilation) Target { - return self.root_mod.resolved_target.result; +pub fn getTarget(self: *const Compilation) *const Target { + return &self.root_mod.resolved_target.result; } /// Only legal to call when cache mode is incremental and a link file is present. @@ -3210,7 +3208,7 @@ fn addNonIncrementalStuffToCacheManifest( man.hash.addOptional(opts.image_base); man.hash.addOptional(opts.gc_sections); man.hash.add(opts.emit_relocs); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; if (target.ofmt == .macho or target.ofmt == .coff) { // TODO remove this, libraries need to be resolved by the frontend. this is already // done by ELF. @@ -6270,7 +6268,7 @@ pub fn addCCArgs( out_dep_path: ?[]const u8, mod: *Package.Module, ) !void { - const target = mod.resolved_target.result; + const target = &mod.resolved_target.result; // As of Clang 16.x, it will by default read extra flags from /etc/clang. // I'm sure the person who implemented this means well, but they have a lot @@ -6944,7 +6942,7 @@ pub const FileExt = enum { }; } - pub fn canonicalName(ext: FileExt, target: Target) [:0]const u8 { + pub fn canonicalName(ext: FileExt, target: *const Target) [:0]const u8 { return switch (ext) { .c => ".c", .cpp => ".cpp", @@ -7187,7 +7185,7 @@ pub fn dump_argv(argv: []const []const u8) void { } pub fn getZigBackend(comp: Compilation) std.builtin.CompilerBackend { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; return target_util.zigBackend(target, comp.config.use_llvm); } @@ -7371,7 +7369,7 @@ pub fn build_crt_file( const basename = try std.zig.binNameAlloc(gpa, .{ .root_name = root_name, - .target = comp.root_mod.resolved_target.result, + .target = &comp.root_mod.resolved_target.result, .output_mode = output_mode, }); @@ -7523,13 +7521,13 @@ pub fn getCrtPaths( comp: *Compilation, arena: Allocator, ) error{ OutOfMemory, LibCInstallationMissingCrtDir }!LibCInstallation.CrtPaths { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; return getCrtPathsInner(arena, target, comp.config, comp.libc_installation, &comp.crt_files); } fn getCrtPathsInner( arena: Allocator, - target: std.Target, + target: *const std.Target, config: Config, libc_installation: ?*const LibCInstallation, crt_files: *std.StringHashMapUnmanaged(CrtFile), @@ -7558,7 +7556,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void { // then when we create a sub-Compilation for zig libc, it also tries to // build kernel32.lib. if (comp.skip_linker_dependencies) return; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; if (target.os.tag != .windows or target.ofmt == .c) return; // This happens when an `extern "foo"` function is referenced. @@ -7574,7 +7572,7 @@ pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode { if (comp.debug_compiler_runtime_libs) { return comp.root_mod.optimize_mode; } - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; switch (comp.root_mod.optimize_mode) { .Debug, .ReleaseSafe => return target_util.defaultCompilerRtOptimizeMode(target), .ReleaseFast => return .ReleaseFast, diff --git a/src/Compilation/Config.zig b/src/Compilation/Config.zig index 637a4bb280db..d8751251da9e 100644 --- a/src/Compilation/Config.zig +++ b/src/Compilation/Config.zig @@ -150,7 +150,7 @@ pub const ResolveError = error{ }; pub fn resolve(options: Options) ResolveError!Config { - const target = options.resolved_target.result; + const target = &options.resolved_target.result; // WASI-only. Resolve the optional exec-model option, defaults to command. if (target.os.tag != .wasi and options.wasi_exec_model != null) diff --git a/src/Package/Module.zig b/src/Package/Module.zig index bcab39415f71..d829b397baf6 100644 --- a/src/Package/Module.zig +++ b/src/Package/Module.zig @@ -102,7 +102,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module { if (options.inherited.error_tracing == true) assert(options.global.any_error_tracing); const resolved_target = options.inherited.resolved_target orelse options.parent.?.resolved_target; - const target = resolved_target.result; + const target = &resolved_target.result; const optimize_mode = options.inherited.optimize_mode orelse if (options.parent) |p| p.optimize_mode else options.global.root_optimize_mode; @@ -363,7 +363,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module { .root_src_path = options.paths.root_src_path, .fully_qualified_name = options.fully_qualified_name, .resolved_target = .{ - .result = target, + .result = target.*, .is_native_os = resolved_target.is_native_os, .is_native_abi = resolved_target.is_native_abi, .is_explicit_dynamic_linker = resolved_target.is_explicit_dynamic_linker, @@ -474,7 +474,7 @@ pub fn getBuiltinOptions(m: Module, global: Compilation.Config) Builtin { assert(global.have_zcu); return .{ .target = m.resolved_target.result, - .zig_backend = target_util.zigBackend(m.resolved_target.result, global.use_llvm), + .zig_backend = target_util.zigBackend(&m.resolved_target.result, global.use_llvm), .output_mode = global.output_mode, .link_mode = global.link_mode, .unwind_tables = m.unwind_tables, diff --git a/src/Sema.zig b/src/Sema.zig index b917e9a31f63..b0786e6ec860 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -29912,7 +29912,7 @@ pub fn coerceInMemoryAllowed( /// load from the `*Src` to effectively perform an in-memory coercion from `Dest` to `Src`. /// Therefore, when `dest_is_mut`, the in-memory coercion must be valid in *both directions*. dest_is_mut: bool, - target: std.Target, + target: *const std.Target, dest_src: LazySrcLoc, src_src: LazySrcLoc, src_val: ?Value, @@ -30271,7 +30271,7 @@ fn coerceInMemoryAllowedFns( src_ty: Type, /// If set, the coercion must be valid in both directions. dest_is_mut: bool, - target: std.Target, + target: *const std.Target, dest_src: LazySrcLoc, src_src: LazySrcLoc, ) !InMemoryCoercionResult { @@ -30380,7 +30380,7 @@ fn coerceInMemoryAllowedFns( } fn callconvCoerceAllowed( - target: std.Target, + target: *const std.Target, src_cc: std.builtin.CallingConvention, dest_cc: std.builtin.CallingConvention, ) bool { @@ -30426,7 +30426,7 @@ fn coerceInMemoryAllowedPtrs( src_ptr_ty: Type, /// If set, the coercion must be valid in both directions. dest_is_mut: bool, - target: std.Target, + target: *const std.Target, dest_src: LazySrcLoc, src_src: LazySrcLoc, ) !InMemoryCoercionResult { diff --git a/src/Type.zig b/src/Type.zig index eafdd65531c4..219ef4a3833a 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -1602,7 +1602,7 @@ fn abiSizeInnerOptional( }; } -pub fn ptrAbiAlignment(target: Target) Alignment { +pub fn ptrAbiAlignment(target: *const Target) Alignment { return Alignment.fromNonzeroByteUnits(@divExact(target.ptrBitWidth(), 8)); } @@ -2395,7 +2395,7 @@ pub fn isAnyFloat(ty: Type) bool { /// Asserts the type is a fixed-size float or comptime_float. /// Returns 128 for comptime_float types. -pub fn floatBits(ty: Type, target: Target) u16 { +pub fn floatBits(ty: Type, target: *const Target) u16 { return switch (ty.toIntern()) { .f16_type => 16, .f32_type => 32, @@ -4188,6 +4188,6 @@ pub fn smallestUnsignedBits(max: u64) u16 { /// to packed struct layout to find out all the places in the codebase you need to edit! pub const packed_struct_layout_version = 2; -fn cTypeAlign(target: Target, c_type: Target.CType) Alignment { +fn cTypeAlign(target: *const Target, c_type: Target.CType) Alignment { return Alignment.fromByteUnits(target.cTypeAlignment(c_type)); } diff --git a/src/Zcu.zig b/src/Zcu.zig index f2d73bb70c44..cb7e8d2a88fb 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -3773,8 +3773,8 @@ pub fn errNote( /// Deprecated. There is no global target for a Zig Compilation Unit. Instead, /// look up the target based on the Module that contains the source code being /// analyzed. -pub fn getTarget(zcu: *const Zcu) Target { - return zcu.root_mod.resolved_target.result; +pub fn getTarget(zcu: *const Zcu) *const Target { + return &zcu.root_mod.resolved_target.result; } /// Deprecated. There is no global optimization mode for a Zig Compilation @@ -3863,7 +3863,7 @@ pub const Feature = enum { }; pub fn backendSupportsFeature(zcu: *const Zcu, comptime feature: Feature) bool { - const backend = target_util.zigBackend(zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm); + const backend = target_util.zigBackend(&zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm); return target_util.backendSupportsFeature(backend, feature); } diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index fd39a66e6ffc..7548fbff3143 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -4382,7 +4382,7 @@ pub fn runCodegen(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air, ou error.CodegenFail => zcu.assertCodegenFailed(zcu.funcInfo(func_index).owner_nav), error.NoLinkFile => assert(zcu.comp.bin_file == null), error.BackendDoesNotProduceMir => switch (target_util.zigBackend( - zcu.root_mod.resolved_target.result, + &zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm, )) { else => unreachable, // assertion failure diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig index a8a60e7ce724..042ee9c11eb1 100644 --- a/src/arch/aarch64/CodeGen.zig +++ b/src/arch/aarch64/CodeGen.zig @@ -6175,7 +6175,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue { self.pt, self.src_loc, val, - self.target.*, + self.target, )) { .mcv => |mcv| switch (mcv) { .none => .none, @@ -6379,7 +6379,7 @@ fn registerAlias(self: *Self, reg: Register, ty: Type) Register { }, .stack_pointer => unreachable, // we can't store/load the sp .floating_point => { - return switch (ty.floatBits(self.target.*)) { + return switch (ty.floatBits(self.target)) { 16 => reg.toH(), 32 => reg.toS(), 64 => reg.toD(), diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig index 98c142086308..799a75be9ae0 100644 --- a/src/arch/arm/CodeGen.zig +++ b/src/arch/arm/CodeGen.zig @@ -6148,7 +6148,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue { pt, self.src_loc, val, - self.target.*, + self.target, )) { .mcv => |mcv| switch (mcv) { .none => .none, diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig index 1743f37e8433..fcaa46666df9 100644 --- a/src/arch/riscv64/CodeGen.zig +++ b/src/arch/riscv64/CodeGen.zig @@ -1881,7 +1881,7 @@ fn memSize(func: *Func, ty: Type) Memory.Size { const pt = func.pt; const zcu = pt.zcu; return switch (ty.zigTypeTag(zcu)) { - .float => Memory.Size.fromBitSize(ty.floatBits(func.target.*)), + .float => Memory.Size.fromBitSize(ty.floatBits(func.target)), else => Memory.Size.fromByteSize(ty.abiSize(zcu)), }; } @@ -2401,7 +2401,7 @@ fn binOp( const rhs_ty = func.typeOf(rhs_air); if (lhs_ty.isRuntimeFloat()) libcall: { - const float_bits = lhs_ty.floatBits(func.target.*); + const float_bits = lhs_ty.floatBits(func.target); const type_needs_libcall = switch (float_bits) { 16 => true, 32, 64 => false, @@ -5189,7 +5189,7 @@ fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { } }, .float => { - const float_bits = lhs_ty.floatBits(func.target.*); + const float_bits = lhs_ty.floatBits(func.target); const float_reg_size: u32 = if (func.hasFeature(.d)) 64 else 32; if (float_bits > float_reg_size) { return func.fail("TODO: airCmp float > 64/32 bits", .{}); @@ -8195,7 +8195,7 @@ fn genTypedValue(func: *Func, val: Value) InnerError!MCValue { const result = if (val.isUndef(pt.zcu)) try lf.lowerUav(pt, val.toIntern(), .none, src_loc) else - try codegen.genTypedValue(lf, pt, src_loc, val, func.target.*); + try codegen.genTypedValue(lf, pt, src_loc, val, func.target); const mcv: MCValue = switch (result) { .mcv => |mcv| switch (mcv) { .none => .none, @@ -8484,7 +8484,7 @@ fn promoteInt(func: *Func, ty: Type) Type { fn promoteVarArg(func: *Func, ty: Type) Type { if (!ty.isRuntimeFloat()) return func.promoteInt(ty); - switch (ty.floatBits(func.target.*)) { + switch (ty.floatBits(func.target)) { 32, 64 => return Type.f64, else => |float_bits| { assert(float_bits == func.target.cTypeBitSize(.longdouble)); diff --git a/src/arch/sparc64/CodeGen.zig b/src/arch/sparc64/CodeGen.zig index 6da576bafc70..5115c432a76b 100644 --- a/src/arch/sparc64/CodeGen.zig +++ b/src/arch/sparc64/CodeGen.zig @@ -4088,7 +4088,7 @@ fn genTypedValue(self: *Self, val: Value) InnerError!MCValue { pt, self.src_loc, val, - self.target.*, + self.target, )) { .mcv => |mcv| switch (mcv) { .none => .none, diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig index 6719f22a7339..9452066bc511 100644 --- a/src/arch/wasm/CodeGen.zig +++ b/src/arch/wasm/CodeGen.zig @@ -982,7 +982,7 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 { pub fn typeToValtype(ty: Type, zcu: *const Zcu, target: *const std.Target) std.wasm.Valtype { const ip = &zcu.intern_pool; return switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(target.*)) { + .float => switch (ty.floatBits(target)) { 16 => .i32, // stored/loaded as u16 32 => .f32, 64 => .f64, @@ -1715,7 +1715,7 @@ fn isByRef(ty: Type, zcu: *const Zcu, target: *const std.Target) bool { .vector => return determineSimdStoreStrategy(ty, zcu, target) == .unrolled, .int => return ty.intInfo(zcu).bits > 64, .@"enum" => return ty.intInfo(zcu).bits > 64, - .float => return ty.floatBits(target.*) > 64, + .float => return ty.floatBits(target) > 64, .error_union => { const pl_ty = ty.errorUnionPayload(zcu); if (!pl_ty.hasRuntimeBitsIgnoreComptime(zcu)) { @@ -2904,7 +2904,7 @@ fn floatOp(cg: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) Inne return cg.fail("TODO: Implement floatOps for vectors", .{}); } - const float_bits = ty.floatBits(cg.target.*); + const float_bits = ty.floatBits(cg.target); if (float_op == .neg) { return cg.floatNeg(ty, args[0]); @@ -2931,7 +2931,7 @@ fn floatOp(cg: *CodeGen, float_op: FloatOp, ty: Type, args: []const WValue) Inne /// NOTE: The result value remains on top of the stack. fn floatNeg(cg: *CodeGen, ty: Type, arg: WValue) InnerError!WValue { - const float_bits = ty.floatBits(cg.target.*); + const float_bits = ty.floatBits(cg.target); switch (float_bits) { 16 => { try cg.emitWValue(arg); @@ -3300,7 +3300,7 @@ fn emitUndefined(cg: *CodeGen, ty: Type) InnerError!WValue { 33...64 => return .{ .imm64 = 0xaaaaaaaaaaaaaaaa }, else => unreachable, }, - .float => switch (ty.floatBits(cg.target.*)) { + .float => switch (ty.floatBits(cg.target)) { 16 => return .{ .imm32 = 0xaaaaaaaa }, 32 => return .{ .float32 = @as(f32, @bitCast(@as(u32, 0xaaaaaaaa))) }, 64 => return .{ .float64 = @as(f64, @bitCast(@as(u64, 0xaaaaaaaaaaaaaaaa))) }, @@ -3507,7 +3507,7 @@ fn cmp(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, op: std.math.CompareOpe /// Compares two floats. /// NOTE: Leaves the result of the comparison on top of the stack. fn cmpFloat(cg: *CodeGen, ty: Type, lhs: WValue, rhs: WValue, cmp_op: std.math.CompareOperator) InnerError!WValue { - const float_bits = ty.floatBits(cg.target.*); + const float_bits = ty.floatBits(cg.target); const op: Op = switch (cmp_op) { .lt => .lt, @@ -4919,7 +4919,7 @@ fn airIntFromFloat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const operand = try cg.resolveInst(ty_op.operand); const op_ty = cg.typeOf(ty_op.operand); - const op_bits = op_ty.floatBits(cg.target.*); + const op_bits = op_ty.floatBits(cg.target); const dest_ty = cg.typeOfIndex(inst); const dest_info = dest_ty.intInfo(zcu); @@ -4973,7 +4973,7 @@ fn airFloatFromInt(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const op_info = op_ty.intInfo(zcu); const dest_ty = cg.typeOfIndex(inst); - const dest_bits = dest_ty.floatBits(cg.target.*); + const dest_bits = dest_ty.floatBits(cg.target); if (op_info.bits > 128) { return cg.fail("TODO: floatFromInt for integers/floats with bitsize {d} bits", .{op_info.bits}); @@ -5567,8 +5567,8 @@ fn airFpext(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { /// Extends a float from a given `Type` to a larger wanted `Type`, leaving the /// result on the stack. fn fpext(cg: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!WValue { - const given_bits = given.floatBits(cg.target.*); - const wanted_bits = wanted.floatBits(cg.target.*); + const given_bits = given.floatBits(cg.target); + const wanted_bits = wanted.floatBits(cg.target); const intrinsic: Mir.Intrinsic = switch (given_bits) { 16 => switch (wanted_bits) { @@ -5621,8 +5621,8 @@ fn airFptrunc(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { /// Truncates a float from a given `Type` to its wanted `Type`, leaving the /// result on the stack. fn fptrunc(cg: *CodeGen, operand: WValue, given: Type, wanted: Type) InnerError!WValue { - const given_bits = given.floatBits(cg.target.*); - const wanted_bits = wanted.floatBits(cg.target.*); + const given_bits = given.floatBits(cg.target); + const wanted_bits = wanted.floatBits(cg.target); const intrinsic: Mir.Intrinsic = switch (given_bits) { 32 => switch (wanted_bits) { @@ -6231,7 +6231,7 @@ fn airMaxMin( if (ty.zigTypeTag(zcu) == .float) { const intrinsic = switch (op) { - inline .fmin, .fmax => |ct_op| switch (ty.floatBits(cg.target.*)) { + inline .fmin, .fmax => |ct_op| switch (ty.floatBits(cg.target)) { inline 16, 32, 64, 80, 128 => |bits| @field( Mir.Intrinsic, libcFloatPrefix(bits) ++ @tagName(ct_op) ++ libcFloatSuffix(bits), @@ -6268,7 +6268,7 @@ fn airMulAdd(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); - const result = if (ty.floatBits(cg.target.*) == 16) fl_result: { + const result = if (ty.floatBits(cg.target) == 16) fl_result: { const rhs_ext = try cg.fpext(rhs, ty, Type.f32); const lhs_ext = try cg.fpext(lhs, ty, Type.f32); const addend_ext = try cg.fpext(addend, ty, Type.f32); @@ -6667,7 +6667,7 @@ fn airDivFloor(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { _ = try cg.wrapOperand(.stack, ty); } } else { - const float_bits = ty.floatBits(cg.target.*); + const float_bits = ty.floatBits(cg.target); if (float_bits > 64) { return cg.fail("TODO: `@divFloor` for floats with bitsize: {d}", .{float_bits}); } diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 49e61e70670e..663154d8843a 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -163704,7 +163704,7 @@ fn allocRegOrMemAdvanced(self: *CodeGen, ty: Type, inst: ?Air.Inst.Index, reg_ok if (reg_ok) need_mem: { if (std.math.isPowerOfTwo(abi_size) and abi_size <= @as(u32, max_abi_size: switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 16, 32, 64, 128 => 16, 80 => break :need_mem, else => unreachable, @@ -163993,9 +163993,9 @@ fn airRetPtr(self: *CodeGen, inst: Air.Inst.Index) !void { fn airFptrunc(self: *CodeGen, inst: Air.Inst.Index) !void { const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; const dst_ty = self.typeOfIndex(inst); - const dst_bits = dst_ty.floatBits(self.target.*); + const dst_bits = dst_ty.floatBits(self.target); const src_ty = self.typeOf(ty_op.operand); - const src_bits = src_ty.floatBits(self.target.*); + const src_bits = src_ty.floatBits(self.target); const result = result: { if (switch (dst_bits) { @@ -164095,10 +164095,10 @@ fn airFpext(self: *CodeGen, inst: Air.Inst.Index) !void { const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; const dst_ty = self.typeOfIndex(inst); const dst_scalar_ty = dst_ty.scalarType(zcu); - const dst_bits = dst_scalar_ty.floatBits(self.target.*); + const dst_bits = dst_scalar_ty.floatBits(self.target); const src_ty = self.typeOf(ty_op.operand); const src_scalar_ty = src_ty.scalarType(zcu); - const src_bits = src_scalar_ty.floatBits(self.target.*); + const src_bits = src_scalar_ty.floatBits(self.target); const result = result: { if (switch (src_bits) { @@ -168207,7 +168207,7 @@ fn floatSign(self: *CodeGen, inst: Air.Inst.Index, tag: Air.Inst.Tag, operand: A const zcu = pt.zcu; const result = result: { - const scalar_bits = ty.scalarType(zcu).floatBits(self.target.*); + const scalar_bits = ty.scalarType(zcu).floatBits(self.target); if (scalar_bits == 80) { if (ty.zigTypeTag(zcu) != .float) return self.fail("TODO implement floatSign for {}", .{ ty.fmt(pt), @@ -168363,14 +168363,14 @@ fn getRoundTag(self: *CodeGen, ty: Type) ?Mir.Inst.FixedTag { const pt = self.pt; const zcu = pt.zcu; return if (self.hasFeature(.sse4_1)) switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .round } else .{ ._sd, .round }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (ty.childType(zcu).floatBits(self.target)) { 32 => switch (ty.vectorLen(zcu)) { 1 => if (self.hasFeature(.avx)) .{ .v_ss, .round } else .{ ._ss, .round }, 2...4 => if (self.hasFeature(.avx)) .{ .v_ps, .round } else .{ ._ps, .round }, @@ -168670,7 +168670,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { const result: MCValue = result: { switch (ty.zigTypeTag(zcu)) { .float => { - const float_bits = ty.floatBits(self.target.*); + const float_bits = ty.floatBits(self.target); if (switch (float_bits) { 16 => !self.hasFeature(.f16c), 32, 64 => false, @@ -168701,7 +168701,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); const mir_tag = @as(?Mir.Inst.FixedTag, switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 16 => { assert(self.hasFeature(.f16c)); const mat_src_reg = if (src_mcv.isRegister()) @@ -168723,7 +168723,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { else => unreachable, }, .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (ty.childType(zcu).floatBits(self.target)) { 16 => if (self.hasFeature(.f16c)) switch (ty.vectorLen(zcu)) { 1 => { try self.asmRegisterRegister( @@ -170904,7 +170904,7 @@ fn genBinOp( const abi_size: u32 = @intCast(lhs_ty.abiSize(zcu)); if (lhs_ty.isRuntimeFloat()) libcall: { - const float_bits = lhs_ty.floatBits(self.target.*); + const float_bits = lhs_ty.floatBits(self.target); const type_needs_libcall = switch (float_bits) { 16 => !self.hasFeature(.f16c), 32, 64 => false, @@ -171083,7 +171083,7 @@ fn genBinOp( }, }; if (sse_op and ((lhs_ty.scalarType(zcu).isRuntimeFloat() and - lhs_ty.scalarType(zcu).floatBits(self.target.*) == 80) or + lhs_ty.scalarType(zcu).floatBits(self.target) == 80) or lhs_ty.abiSize(zcu) > self.vectorSize(.float))) return self.fail("TODO implement genBinOp for {s} {}", .{ @tagName(air_tag), lhs_ty.fmt(pt) }); @@ -171474,7 +171474,7 @@ fn genBinOp( const dst_reg = registerAlias(dst_mcv.getReg().?, abi_size); const mir_tag = @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { else => unreachable, - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 16 => { assert(self.hasFeature(.f16c)); const lhs_reg = if (copied_to_dst) dst_reg else registerAlias(lhs_mcv.getReg().?, abi_size); @@ -171917,7 +171917,7 @@ fn genBinOp( }, else => null, }, - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 16 => tag: { assert(self.hasFeature(.f16c)); const lhs_reg = if (copied_to_dst) dst_reg else registerAlias(lhs_mcv.getReg().?, abi_size); @@ -172336,14 +172336,14 @@ fn genBinOp( try self.asmRegisterRegisterRegisterImmediate( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 32 => .{ .v_ss, .cmp }, 64 => .{ .v_sd, .cmp }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 32 => switch (lhs_ty.vectorLen(zcu)) { 1 => .{ .v_ss, .cmp }, 2...8 => .{ .v_ps, .cmp }, @@ -172370,14 +172370,14 @@ fn genBinOp( ); try self.asmRegisterRegisterRegisterRegister( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 32 => .{ .v_ps, .blendv }, 64 => .{ .v_pd, .blendv }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 32 => switch (lhs_ty.vectorLen(zcu)) { 1...8 => .{ .v_ps, .blendv }, else => null, @@ -172404,14 +172404,14 @@ fn genBinOp( const has_blend = self.hasFeature(.sse4_1); try self.asmRegisterRegisterImmediate( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 32 => .{ ._ss, .cmp }, 64 => .{ ._sd, .cmp }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 32 => switch (lhs_ty.vectorLen(zcu)) { 1 => .{ ._ss, .cmp }, 2...4 => .{ ._ps, .cmp }, @@ -172437,14 +172437,14 @@ fn genBinOp( ); if (has_blend) try self.asmRegisterRegisterRegister( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 32 => .{ ._ps, .blendv }, 64 => .{ ._pd, .blendv }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 32 => switch (lhs_ty.vectorLen(zcu)) { 1...4 => .{ ._ps, .blendv }, else => null, @@ -172467,14 +172467,14 @@ fn genBinOp( mask_reg, ) else { const mir_fixes = @as(?Mir.Inst.Fixes, switch (lhs_ty.zigTypeTag(zcu)) { - .float => switch (lhs_ty.floatBits(self.target.*)) { + .float => switch (lhs_ty.floatBits(self.target)) { 32 => ._ps, 64 => ._pd, 16, 80, 128 => null, else => unreachable, }, .vector => switch (lhs_ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (lhs_ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (lhs_ty.childType(zcu).floatBits(self.target)) { 32 => switch (lhs_ty.vectorLen(zcu)) { 1...4 => ._ps, else => null, @@ -173832,7 +173832,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v switch (ty.zigTypeTag(zcu)) { .float => { - const float_bits = ty.floatBits(self.target.*); + const float_bits = ty.floatBits(self.target); if (!switch (float_bits) { 16 => self.hasFeature(.f16c), 32 => self.hasFeature(.sse), @@ -174188,7 +174188,7 @@ fn airCmp(self: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) !v defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); const src_mcv = if (flipped) lhs_mcv else rhs_mcv; - switch (ty.floatBits(self.target.*)) { + switch (ty.floatBits(self.target)) { 16 => { assert(self.hasFeature(.f16c)); const tmp1_reg = @@ -176335,7 +176335,7 @@ fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !M else => {}, } }, - .float => switch (ty.floatBits(cg.target.*)) { + .float => switch (ty.floatBits(cg.target)) { 16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ .insert = .{ .vp_w, .insr }, .extract = .{ .vp_w, .extr }, @@ -176482,7 +176482,7 @@ fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !M } else unreachable, - .float => switch (ty.childType(zcu).floatBits(cg.target.*)) { + .float => switch (ty.childType(zcu).floatBits(cg.target)) { 16 => switch (ty.vectorLen(zcu)) { 1...8 => return .{ .load_store = if (cg.hasFeature(.avx)) .{ if (aligned) .v_dqa else .v_dqu, .mov } @@ -177017,7 +177017,7 @@ fn genSetReg( 17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null, else => null, }, - .float => switch (ty.scalarType(zcu).floatBits(self.target.*)) { + .float => switch (ty.scalarType(zcu).floatBits(self.target)) { 16, 128 => switch (abi_size) { 2...16 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } @@ -177776,7 +177776,7 @@ fn airFloatFromInt(self: *CodeGen, inst: Air.Inst.Index) !void { const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; const dst_ty = self.typeOfIndex(inst); - const dst_bits = dst_ty.floatBits(self.target.*); + const dst_bits = dst_ty.floatBits(self.target); const src_ty = self.typeOf(ty_op.operand); const src_bits: u32 = @intCast(src_ty.bitSize(zcu)); @@ -177828,7 +177828,7 @@ fn airFloatFromInt(self: *CodeGen, inst: Air.Inst.Index) !void { defer self.register_manager.unlockReg(dst_lock); const mir_tag = @as(?Mir.Inst.FixedTag, switch (dst_ty.zigTypeTag(zcu)) { - .float => switch (dst_ty.floatBits(self.target.*)) { + .float => switch (dst_ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .cvtsi2 } else .{ ._ss, .cvtsi2 }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .cvtsi2 } else .{ ._sd, .cvtsi2 }, 16, 80, 128 => null, @@ -177865,7 +177865,7 @@ fn airIntFromFloat(self: *CodeGen, inst: Air.Inst.Index) !void { }, 32), 8) catch unreachable; const src_ty = self.typeOf(ty_op.operand); - const src_bits = src_ty.floatBits(self.target.*); + const src_bits = src_ty.floatBits(self.target); const result = result: { if (switch (src_bits) { @@ -178136,22 +178136,22 @@ fn atomicOp( } if (rmw_op) |op| if (use_sse) { const mir_tag = @as(?Mir.Inst.FixedTag, switch (op) { - .Add => switch (val_ty.floatBits(self.target.*)) { + .Add => switch (val_ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .add } else .{ ._ss, .add }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .add } else .{ ._sd, .add }, else => null, }, - .Sub => switch (val_ty.floatBits(self.target.*)) { + .Sub => switch (val_ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .sub } else .{ ._ss, .sub }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .sub } else .{ ._sd, .sub }, else => null, }, - .Min => switch (val_ty.floatBits(self.target.*)) { + .Min => switch (val_ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .min } else .{ ._ss, .min }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .min } else .{ ._sd, .min }, else => null, }, - .Max => switch (val_ty.floatBits(self.target.*)) { + .Max => switch (val_ty.floatBits(self.target)) { 32 => if (self.hasFeature(.avx)) .{ .v_ss, .max } else .{ ._ss, .max }, 64 => if (self.hasFeature(.avx)) .{ .v_sd, .max } else .{ ._sd, .max }, else => null, @@ -178988,7 +178988,7 @@ fn airSplat(self: *CodeGen, inst: Air.Inst.Index) !void { ); break :result .{ .register = dst_reg }; }, - .float => switch (scalar_ty.floatBits(self.target.*)) { + .float => switch (scalar_ty.floatBits(self.target)) { 32 => switch (vector_len) { 1 => { const src_mcv = try self.resolveInst(ty_op.operand); @@ -179581,7 +179581,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { null, else => null, }, - .float => switch (elem_ty.floatBits(self.target.*)) { + .float => switch (elem_ty.floatBits(self.target)) { else => unreachable, 16, 80, 128 => null, 32 => switch (vec_len) { @@ -180308,7 +180308,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void { defer self.register_manager.unlockReg(mask_lock); const mir_fixes: Mir.Inst.Fixes = if (elem_ty.isRuntimeFloat()) - switch (elem_ty.floatBits(self.target.*)) { + switch (elem_ty.floatBits(self.target)) { 16, 80, 128 => .p_, 32 => ._ps, 64 => ._pd, @@ -180414,7 +180414,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void { .{ switch (elem_ty.zigTypeTag(zcu)) { else => break :result null, .int => .vp_, - .float => switch (elem_ty.floatBits(self.target.*)) { + .float => switch (elem_ty.floatBits(self.target)) { 32 => .v_ps, 64 => .v_pd, 16, 80, 128 => break :result null, @@ -180428,7 +180428,7 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void { .{ switch (elem_ty.zigTypeTag(zcu)) { else => break :result null, .int => .p_, - .float => switch (elem_ty.floatBits(self.target.*)) { + .float => switch (elem_ty.floatBits(self.target)) { 32 => ._ps, 64 => ._pd, 16, 80, 128 => break :result null, @@ -180800,7 +180800,7 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void { const ops = [3]Air.Inst.Ref{ extra.lhs, extra.rhs, pl_op.operand }; const result = result: { - if (switch (ty.scalarType(zcu).floatBits(self.target.*)) { + if (switch (ty.scalarType(zcu).floatBits(self.target)) { 16, 80, 128 => true, 32, 64 => !self.hasFeature(.fma), else => unreachable, @@ -180855,14 +180855,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void { const mir_tag = @as(?Mir.Inst.FixedTag, if (std.mem.eql(u2, &order, &.{ 1, 3, 2 }) or std.mem.eql(u2, &order, &.{ 3, 1, 2 })) switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 32 => .{ .v_ss, .fmadd132 }, 64 => .{ .v_sd, .fmadd132 }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (ty.childType(zcu).floatBits(self.target)) { 32 => switch (ty.vectorLen(zcu)) { 1 => .{ .v_ss, .fmadd132 }, 2...8 => .{ .v_ps, .fmadd132 }, @@ -180882,14 +180882,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void { } else if (std.mem.eql(u2, &order, &.{ 2, 1, 3 }) or std.mem.eql(u2, &order, &.{ 1, 2, 3 })) switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 32 => .{ .v_ss, .fmadd213 }, 64 => .{ .v_sd, .fmadd213 }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (ty.childType(zcu).floatBits(self.target)) { 32 => switch (ty.vectorLen(zcu)) { 1 => .{ .v_ss, .fmadd213 }, 2...8 => .{ .v_ps, .fmadd213 }, @@ -180909,14 +180909,14 @@ fn airMulAdd(self: *CodeGen, inst: Air.Inst.Index) !void { } else if (std.mem.eql(u2, &order, &.{ 2, 3, 1 }) or std.mem.eql(u2, &order, &.{ 3, 2, 1 })) switch (ty.zigTypeTag(zcu)) { - .float => switch (ty.floatBits(self.target.*)) { + .float => switch (ty.floatBits(self.target)) { 32 => .{ .v_ss, .fmadd231 }, 64 => .{ .v_sd, .fmadd231 }, 16, 80, 128 => null, else => unreachable, }, .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { - .float => switch (ty.childType(zcu).floatBits(self.target.*)) { + .float => switch (ty.childType(zcu).floatBits(self.target)) { 32 => switch (ty.vectorLen(zcu)) { 1 => .{ .v_ss, .fmadd231 }, 2...8 => .{ .v_ps, .fmadd231 }, @@ -181979,7 +181979,7 @@ fn promoteInt(self: *CodeGen, ty: Type) Type { fn promoteVarArg(self: *CodeGen, ty: Type) Type { if (!ty.isRuntimeFloat()) return self.promoteInt(ty); - switch (ty.floatBits(self.target.*)) { + switch (ty.floatBits(self.target)) { 32, 64 => return .f64, else => |float_bits| { assert(float_bits == self.target.cTypeBitSize(.longdouble)); @@ -182080,7 +182080,7 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int { } fn floatBits(cg: *CodeGen, ty: Type) ?u16 { - return if (ty.isRuntimeFloat()) ty.floatBits(cg.target.*) else null; + return if (ty.isRuntimeFloat()) ty.floatBits(cg.target) else null; } const Temp = struct { diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig index e6b4ac26bbfa..8904dada8ca1 100644 --- a/src/arch/x86_64/Emit.zig +++ b/src/arch/x86_64/Emit.zig @@ -105,7 +105,7 @@ pub fn emitMir(emit: *Emit) Error!void { emit.pt, emit.lower.src_loc, nav, - emit.lower.target.*, + emit.lower.target, )) { .mcv => |mcv| mcv.lea_symbol, .fail => |em| { @@ -542,7 +542,7 @@ pub fn emitMir(emit: *Emit) Error!void { emit.pt, emit.lower.src_loc, nav, - emit.lower.target.*, + emit.lower.target, ) catch |err| switch (err) { error.CodegenFail, => return emit.fail("unable to codegen: {s}", .{@errorName(err)}), diff --git a/src/arch/x86_64/abi.zig b/src/arch/x86_64/abi.zig index 8e700eebc6b0..43cb4003bee7 100644 --- a/src/arch/x86_64/abi.zig +++ b/src/arch/x86_64/abi.zig @@ -148,7 +148,7 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont result[0] = .integer; return result; }, - .float => switch (ty.floatBits(target.*)) { + .float => switch (ty.floatBits(target)) { 16 => { if (ctx == .field) { result[0] = .memory; diff --git a/src/codegen.zig b/src/codegen.zig index 0e10992d07e9..d1b62e352eea 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -65,7 +65,7 @@ fn importBackend(comptime backend: std.builtin.CompilerBackend) type { pub fn legalizeFeatures(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) ?*const Air.Legalize.Features { const zcu = pt.zcu; const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; - switch (target_util.zigBackend(target.*, zcu.comp.config.use_llvm)) { + switch (target_util.zigBackend(target, zcu.comp.config.use_llvm)) { else => unreachable, inline .stage2_llvm, .stage2_c, @@ -114,7 +114,7 @@ pub const AnyMir = union { pub fn deinit(mir: *AnyMir, zcu: *const Zcu) void { const gpa = zcu.gpa; - const backend = target_util.zigBackend(zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm); + const backend = target_util.zigBackend(&zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm); switch (backend) { else => unreachable, inline .stage2_aarch64, @@ -145,7 +145,7 @@ pub fn generateFunction( ) CodeGenError!AnyMir { const zcu = pt.zcu; const func = zcu.funcInfo(func_index); - const target = zcu.navFileScope(func.owner_nav).mod.?.resolved_target.result; + const target = &zcu.navFileScope(func.owner_nav).mod.?.resolved_target.result; switch (target_util.zigBackend(target, false)) { else => unreachable, inline .stage2_aarch64, @@ -183,7 +183,7 @@ pub fn emitFunction( ) CodeGenError!void { const zcu = pt.zcu; const func = zcu.funcInfo(func_index); - const target = zcu.navFileScope(func.owner_nav).mod.?.resolved_target.result; + const target = &zcu.navFileScope(func.owner_nav).mod.?.resolved_target.result; switch (target_util.zigBackend(target, zcu.comp.config.use_llvm)) { else => unreachable, inline .stage2_aarch64, @@ -210,7 +210,7 @@ pub fn generateLazyFunction( ) CodeGenError!void { const zcu = pt.zcu; const target = if (Type.fromInterned(lazy_sym.ty).typeDeclInstAllowGeneratedTag(zcu)) |inst_index| - zcu.fileByIndex(inst_index.resolveFile(&zcu.intern_pool)).mod.?.resolved_target.result + &zcu.fileByIndex(inst_index.resolveFile(&zcu.intern_pool)).mod.?.resolved_target.result else zcu.getTarget(); switch (target_util.zigBackend(target, zcu.comp.config.use_llvm)) { @@ -225,7 +225,7 @@ pub fn generateLazyFunction( } } -fn writeFloat(comptime F: type, f: F, target: std.Target, endian: std.builtin.Endian, code: []u8) void { +fn writeFloat(comptime F: type, f: F, target: *const std.Target, endian: std.builtin.Endian, code: []u8) void { _ = target; const bits = @typeInfo(F).float.bits; const Int = @Type(.{ .int = .{ .signedness = .unsigned, .bits = bits } }); @@ -253,7 +253,7 @@ pub fn generateLazySymbol( const gpa = comp.gpa; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const endian = target.cpu.arch.endian(); log.debug("generateLazySymbol: kind = {s}, ty = {}", .{ @@ -839,7 +839,7 @@ fn lowerNavRef( const zcu = pt.zcu; const gpa = zcu.gpa; const ip = &zcu.intern_pool; - const target = zcu.navFileScope(nav_index).mod.?.resolved_target.result; + const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; const ptr_width_bytes = @divExact(target.ptrBitWidth(), 8); const is_obj = lf.comp.config.output_mode == .Obj; const nav_ty = Type.fromInterned(ip.getNav(nav_index).typeOf(ip)); @@ -956,7 +956,7 @@ pub fn genNavRef( pt: Zcu.PerThread, src_loc: Zcu.LazySrcLoc, nav_index: InternPool.Nav.Index, - target: std.Target, + target: *const std.Target, ) CodeGenError!GenResult { const zcu = pt.zcu; const ip = &zcu.intern_pool; @@ -1040,9 +1040,9 @@ pub fn genTypedValue( pt: Zcu.PerThread, src_loc: Zcu.LazySrcLoc, val: Value, - target: std.Target, + target: *const std.Target, ) CodeGenError!GenResult { - return switch (try lowerValue(pt, val, &target)) { + return switch (try lowerValue(pt, val, target)) { .none => .{ .mcv = .none }, .undef => .{ .mcv = .undef }, .immediate => |imm| .{ .mcv = .{ .immediate = imm } }, diff --git a/src/codegen/c.zig b/src/codegen/c.zig index 110c5a312702..7ee33577d8c8 100644 --- a/src/codegen/c.zig +++ b/src/codegen/c.zig @@ -1080,7 +1080,7 @@ pub const DeclGen = struct { }, .enum_tag => |enum_tag| try dg.renderValue(writer, Value.fromInterned(enum_tag.int), location), .float => { - const bits = ty.floatBits(target.*); + const bits = ty.floatBits(target); const f128_val = val.toFloat(f128, zcu); // All unsigned ints matching float types are pre-allocated. @@ -1608,7 +1608,7 @@ pub const DeclGen = struct { .f80_type, .f128_type, => { - const bits = ty.floatBits(target.*); + const bits = ty.floatBits(target); // All unsigned ints matching float types are pre-allocated. const repr_ty = dg.pt.intType(.unsigned, bits) catch unreachable; @@ -6543,7 +6543,7 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue { const scalar_ty = operand_ty.scalarType(zcu); const target = &f.object.dg.mod.resolved_target.result; const operation = if (inst_scalar_ty.isRuntimeFloat() and scalar_ty.isRuntimeFloat()) - if (inst_scalar_ty.floatBits(target.*) < scalar_ty.floatBits(target.*)) "trunc" else "extend" + if (inst_scalar_ty.floatBits(target) < scalar_ty.floatBits(target)) "trunc" else "extend" else if (inst_scalar_ty.isInt(zcu) and scalar_ty.isRuntimeFloat()) if (inst_scalar_ty.isSignedInt(zcu)) "fix" else "fixuns" else if (inst_scalar_ty.isRuntimeFloat() and scalar_ty.isInt(zcu)) @@ -6565,8 +6565,8 @@ fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue { } try writer.writeAll("zig_"); try writer.writeAll(operation); - try writer.writeAll(compilerRtAbbrev(scalar_ty, zcu, target.*)); - try writer.writeAll(compilerRtAbbrev(inst_scalar_ty, zcu, target.*)); + try writer.writeAll(compilerRtAbbrev(scalar_ty, zcu, target)); + try writer.writeAll(compilerRtAbbrev(inst_scalar_ty, zcu, target)); try writer.writeByte('('); try f.writeCValue(writer, operand, .FunctionArgument); try v.elem(f, writer); @@ -8073,7 +8073,7 @@ fn signAbbrev(signedness: std.builtin.Signedness) u8 { }; } -fn compilerRtAbbrev(ty: Type, zcu: *Zcu, target: std.Target) []const u8 { +fn compilerRtAbbrev(ty: Type, zcu: *Zcu, target: *const std.Target) []const u8 { return if (ty.isInt(zcu)) switch (ty.intInfo(zcu).bits) { 1...32 => "si", 33...64 => "di", diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig index e5901ec6265d..044d947702b5 100644 --- a/src/codegen/c/Type.zig +++ b/src/codegen/c/Type.zig @@ -1319,9 +1319,9 @@ pub const Pool = struct { }, else => { const target = &mod.resolved_target.result; - const abi_align_bytes = std.zig.target.intAlignment(target.*, int_info.bits); + const abi_align_bytes = std.zig.target.intAlignment(target, int_info.bits); const array_ctype = try pool.getArray(allocator, .{ - .len = @divExact(std.zig.target.intByteSize(target.*, int_info.bits), abi_align_bytes), + .len = @divExact(std.zig.target.intByteSize(target, int_info.bits), abi_align_bytes), .elem_ctype = try pool.fromIntInfo(allocator, .{ .signedness = .unsigned, .bits = @intCast(abi_align_bytes * 8), @@ -1438,13 +1438,13 @@ pub const Pool = struct { .elem_ctype = .u8, .@"const" = true, }), - .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target.*)), + .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)), }, .{ .name = .{ .index = .len }, .ctype = .usize, .alignas = AlignAs.fromAbiAlignment( - .fromByteUnits(std.zig.target.intAlignment(target.*, target.ptrBitWidth())), + .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())), ), }, }; @@ -2246,13 +2246,13 @@ pub const Pool = struct { mod, kind, ), - .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target.*)), + .alignas = AlignAs.fromAbiAlignment(Type.ptrAbiAlignment(target)), }, .{ .name = .{ .index = .len }, .ctype = .usize, .alignas = AlignAs.fromAbiAlignment( - .fromByteUnits(std.zig.target.intAlignment(target.*, target.ptrBitWidth())), + .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())), ), }, }; @@ -2372,7 +2372,7 @@ pub const Pool = struct { .name = .{ .index = .@"error" }, .ctype = error_set_ctype, .alignas = AlignAs.fromAbiAlignment( - .fromByteUnits(std.zig.target.intAlignment(target.*, error_set_bits)), + .fromByteUnits(std.zig.target.intAlignment(target, error_set_bits)), ), }, .{ diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index b4950179c4e6..146148470f58 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -43,7 +43,7 @@ pub fn legalizeFeatures(_: *const std.Target) ?*const Air.Legalize.Features { }); } -fn subArchName(target: std.Target, comptime family: std.Target.Cpu.Arch.Family, mappings: anytype) ?[]const u8 { +fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.Family, mappings: anytype) ?[]const u8 { inline for (mappings) |mapping| { if (target.cpu.has(family, mapping[0])) return mapping[1]; } @@ -51,7 +51,7 @@ fn subArchName(target: std.Target, comptime family: std.Target.Cpu.Arch.Family, return null; } -pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 { +pub fn targetTriple(allocator: Allocator, target: *const std.Target) ![]const u8 { var llvm_triple = std.ArrayList(u8).init(allocator); defer llvm_triple.deinit(); @@ -309,7 +309,7 @@ pub fn targetTriple(allocator: Allocator, target: std.Target) ![]const u8 { return llvm_triple.toOwnedSlice(); } -pub fn supportsTailCall(target: std.Target) bool { +pub fn supportsTailCall(target: *const std.Target) bool { return switch (target.cpu.arch) { .wasm32, .wasm64 => target.cpu.has(.wasm, .tail_call), // Although these ISAs support tail calls, LLVM does not support tail calls on them. @@ -319,7 +319,7 @@ pub fn supportsTailCall(target: std.Target) bool { }; } -pub fn dataLayout(target: std.Target) []const u8 { +pub fn dataLayout(target: *const std.Target) []const u8 { // These data layouts should match Clang. return switch (target.cpu.arch) { .arc => "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-f32:32:32-i64:32-f64:32-a:0:32-n32", @@ -475,7 +475,7 @@ const CodeModel = enum { large, }; -fn codeModel(model: std.builtin.CodeModel, target: std.Target) CodeModel { +fn codeModel(model: std.builtin.CodeModel, target: *const std.Target) CodeModel { // Roughly match Clang's mapping of GCC code models to LLVM code models. return switch (model) { .default => .default, @@ -508,7 +508,7 @@ pub const Object = struct { debug_unresolved_namespace_scopes: std.AutoArrayHashMapUnmanaged(InternPool.NamespaceIndex, Builder.Metadata), - target: std.Target, + target: *const std.Target, /// Ideally we would use `llvm_module.getNamedFunction` to go from *Decl to LLVM function, /// but that has some downsides: /// * we have to compute the fully qualified name every time we want to do the lookup @@ -562,7 +562,7 @@ pub const Object = struct { pub fn create(arena: Allocator, comp: *Compilation) !Ptr { dev.check(.llvm_backend); const gpa = comp.gpa; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const llvm_target_triple = try targetTriple(arena, target); var builder = try Builder.init(.{ @@ -827,7 +827,7 @@ pub const Object = struct { const behavior_max = try o.builder.metadataConstant(try o.builder.intConst(.i32, 7)); const behavior_min = try o.builder.metadataConstant(try o.builder.intConst(.i32, 8)); - if (target_util.llvmMachineAbi(comp.root_mod.resolved_target.result)) |abi| { + if (target_util.llvmMachineAbi(&comp.root_mod.resolved_target.result)) |abi| { module_flags.appendAssumeCapacity(try o.builder.metadataModuleFlag( behavior_error, try o.builder.metadataString("target-abi"), @@ -837,7 +837,7 @@ pub const Object = struct { )); } - const pic_level = target_util.picLevel(comp.root_mod.resolved_target.result); + const pic_level = target_util.picLevel(&comp.root_mod.resolved_target.result); if (comp.root_mod.pic) { module_flags.appendAssumeCapacity(try o.builder.metadataModuleFlag( behavior_min, @@ -860,7 +860,7 @@ pub const Object = struct { try o.builder.metadataString("Code Model"), try o.builder.metadataConstant(try o.builder.intConst(.i32, @as( i32, - switch (codeModel(comp.root_mod.code_model, comp.root_mod.resolved_target.result)) { + switch (codeModel(comp.root_mod.code_model, &comp.root_mod.resolved_target.result)) { .default => unreachable, .tiny => 0, .small => 1, @@ -906,7 +906,7 @@ pub const Object = struct { } } - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; if (target.os.tag == .windows and (target.cpu.arch == .x86_64 or target.cpu.arch == .x86)) { // Add the "RegCallv4" flag so that any functions using `x86_regcallcc` use regcall // v4, which is essentially a requirement on Windows. See corresponding logic in @@ -1020,7 +1020,7 @@ pub const Object = struct { else .Static; - const code_model: llvm.CodeModel = switch (codeModel(comp.root_mod.code_model, comp.root_mod.resolved_target.result)) { + const code_model: llvm.CodeModel = switch (codeModel(comp.root_mod.code_model, &comp.root_mod.resolved_target.result)) { .default => .Default, .tiny => .Tiny, .small => .Small, @@ -1045,7 +1045,7 @@ pub const Object = struct { comp.function_sections, comp.data_sections, float_abi, - if (target_util.llvmMachineAbi(comp.root_mod.resolved_target.result)) |s| s.ptr else null, + if (target_util.llvmMachineAbi(&comp.root_mod.resolved_target.result)) |s| s.ptr else null, ); errdefer target_machine.dispose(); @@ -1137,7 +1137,7 @@ pub const Object = struct { const owner_mod = zcu.fileByIndex(file_scope).mod.?; const fn_ty = Type.fromInterned(func.ty); const fn_info = zcu.typeToFunc(fn_ty).?; - const target = owner_mod.resolved_target.result; + const target = &owner_mod.resolved_target.result; var ng: NavGen = .{ .object = o, @@ -2699,7 +2699,7 @@ pub const Object = struct { if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.function; const fn_info = zcu.typeToFunc(ty).?; - const target = owner_mod.resolved_target.result; + const target = &owner_mod.resolved_target.result; const sret = firstParamSRet(fn_info, zcu, target); const is_extern, const lib_name = if (nav.getExtern(ip)) |@"extern"| @@ -2913,7 +2913,7 @@ pub const Object = struct { try attributes.addFnAttr(.minsize, &o.builder); try attributes.addFnAttr(.optsize, &o.builder); } - const target = owner_mod.resolved_target.result; + const target = &owner_mod.resolved_target.result; if (target.cpu.model.llvm_name) |s| { try attributes.addFnAttr(.{ .string = .{ .kind = try o.builder.string("target-cpu"), @@ -4445,7 +4445,7 @@ pub const Object = struct { if (o.builder.getGlobal(name)) |llvm_fn| return llvm_fn.ptrConst(&o.builder).kind.function; const zcu = o.pt.zcu; - const target = zcu.root_mod.resolved_target.result; + const target = &zcu.root_mod.resolved_target.result; const function_index = try o.builder.addFunction( try o.builder.fnType(.i1, &.{try o.errorIntType()}, .normal), name, @@ -4474,7 +4474,7 @@ pub const Object = struct { const usize_ty = try o.lowerType(Type.usize); const ret_ty = try o.lowerType(Type.slice_const_u8_sentinel_0); - const target = zcu.root_mod.resolved_target.result; + const target = &zcu.root_mod.resolved_target.result; const function_index = try o.builder.addFunction( try o.builder.fnType(ret_ty, &.{try o.lowerType(Type.fromInterned(enum_type.tag_ty))}, .normal), try o.builder.strtabStringFmt("__zig_tag_name_{}", .{enum_type.name.fmt(ip)}), @@ -10372,7 +10372,7 @@ pub const FuncGen = struct { if (gop.found_existing) return gop.value_ptr.*; errdefer assert(o.named_enum_map.remove(enum_ty.toIntern())); - const target = zcu.root_mod.resolved_target.result; + const target = &zcu.root_mod.resolved_target.result; const function_index = try o.builder.addFunction( try o.builder.fnType(.i1, &.{try o.lowerType(Type.fromInterned(enum_type.tag_ty))}, .normal), try o.builder.strtabStringFmt("__zig_is_named_enum_value_{}", .{enum_type.name.fmt(ip)}), @@ -11834,7 +11834,7 @@ const CallingConventionInfo = struct { inreg_param_count: u2 = 0, }; -pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) ?CallingConventionInfo { +pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Target) ?CallingConventionInfo { const llvm_cc = toLlvmCallConvTag(cc, target) orelse return null; const incoming_stack_alignment: ?u64, const register_params: u2 = switch (cc) { inline else => |pl| switch (@TypeOf(pl)) { @@ -11858,7 +11858,7 @@ pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: std.Target) ?Ca .inreg_param_count = register_params, }; } -fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: std.Target) ?Builder.CallConv { +fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *const std.Target) ?Builder.CallConv { if (target.cCallingConvention()) |default_c| { if (cc_tag == default_c) { return .ccc; @@ -11972,7 +11972,7 @@ fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: std.Targ } /// Convert a zig-address space to an llvm address space. -fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: std.Target) Builder.AddrSpace { +fn toLlvmAddressSpace(address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace { for (llvmAddrSpaceInfo(target)) |info| if (info.zig == address_space) return info.llvm; unreachable; } @@ -11987,7 +11987,7 @@ const AddrSpaceInfo = struct { idx: ?u16 = null, force_in_data_layout: bool = false, }; -fn llvmAddrSpaceInfo(target: std.Target) []const AddrSpaceInfo { +fn llvmAddrSpaceInfo(target: *const std.Target) []const AddrSpaceInfo { return switch (target.cpu.arch) { .x86, .x86_64 => &.{ .{ .zig = .generic, .llvm = .default }, @@ -12063,7 +12063,7 @@ fn llvmAddrSpaceInfo(target: std.Target) []const AddrSpaceInfo { /// different address, space and then cast back to the generic address space. /// For example, on GPUs local variable declarations must be generated into the local address space. /// This function returns the address space local values should be generated into. -fn llvmAllocaAddressSpace(target: std.Target) Builder.AddrSpace { +fn llvmAllocaAddressSpace(target: *const std.Target) Builder.AddrSpace { return switch (target.cpu.arch) { // On amdgcn, locals should be generated into the private address space. // To make Zig not impossible to use, these are then converted to addresses in the @@ -12075,7 +12075,7 @@ fn llvmAllocaAddressSpace(target: std.Target) Builder.AddrSpace { /// On some targets, global values that are in the generic address space must be generated into a /// different address space, and then cast back to the generic address space. -fn llvmDefaultGlobalAddressSpace(target: std.Target) Builder.AddrSpace { +fn llvmDefaultGlobalAddressSpace(target: *const std.Target) Builder.AddrSpace { return switch (target.cpu.arch) { // On amdgcn, globals must be explicitly allocated and uploaded so that the program can access // them. @@ -12086,14 +12086,14 @@ fn llvmDefaultGlobalAddressSpace(target: std.Target) Builder.AddrSpace { /// Return the actual address space that a value should be stored in if its a global address space. /// When a value is placed in the resulting address space, it needs to be cast back into wanted_address_space. -fn toLlvmGlobalAddressSpace(wanted_address_space: std.builtin.AddressSpace, target: std.Target) Builder.AddrSpace { +fn toLlvmGlobalAddressSpace(wanted_address_space: std.builtin.AddressSpace, target: *const std.Target) Builder.AddrSpace { return switch (wanted_address_space) { .generic => llvmDefaultGlobalAddressSpace(target), else => |as| toLlvmAddressSpace(as, target), }; } -fn returnTypeByRef(zcu: *Zcu, target: std.Target, ty: Type) bool { +fn returnTypeByRef(zcu: *Zcu, target: *const std.Target, ty: Type) bool { if (isByRef(ty, zcu)) { return true; } else if (target.cpu.arch.isX86() and @@ -12108,7 +12108,7 @@ fn returnTypeByRef(zcu: *Zcu, target: std.Target, ty: Type) bool { } } -fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: std.Target) bool { +fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: *const std.Target) bool { const return_type = Type.fromInterned(fn_info.return_type); if (!return_type.hasRuntimeBitsIgnoreComptime(zcu)) return false; @@ -12137,8 +12137,8 @@ fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: std.Targe }; } -fn firstParamSRetSystemV(ty: Type, zcu: *Zcu, target: std.Target) bool { - const class = x86_64_abi.classifySystemV(ty, zcu, &target, .ret); +fn firstParamSRetSystemV(ty: Type, zcu: *Zcu, target: *const std.Target) bool { + 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; return false; @@ -12238,8 +12238,7 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E if (isScalar(zcu, return_type)) { return o.lowerType(return_type); } - const target = zcu.getTarget(); - const classes = x86_64_abi.classifySystemV(return_type, zcu, &target, .ret); + const classes = x86_64_abi.classifySystemV(return_type, zcu, zcu.getTarget(), .ret); if (classes[0] == .memory) return .void; var types_index: u32 = 0; var types_buffer: [8]Builder.Type = undefined; @@ -12527,8 +12526,7 @@ const ParamTypeIterator = struct { fn nextSystemV(it: *ParamTypeIterator, ty: Type) Allocator.Error!?Lowering { const zcu = it.object.pt.zcu; const ip = &zcu.intern_pool; - const target = zcu.getTarget(); - const classes = x86_64_abi.classifySystemV(ty, zcu, &target, .arg); + const classes = x86_64_abi.classifySystemV(ty, zcu, zcu.getTarget(), .arg); if (classes[0] == .memory) { it.zig_index += 1; it.llvm_index += 1; @@ -12794,7 +12792,7 @@ fn isScalar(zcu: *Zcu, ty: Type) bool { /// This function returns true if we expect LLVM to lower x86_fp80 correctly /// and false if we expect LLVM to crash if it encounters an x86_fp80 type, /// or if it produces miscompilations. -fn backendSupportsF80(target: std.Target) bool { +fn backendSupportsF80(target: *const std.Target) bool { return switch (target.cpu.arch) { .x86, .x86_64 => !target.cpu.has(.x86, .soft_float), else => false, @@ -12804,7 +12802,7 @@ fn backendSupportsF80(target: std.Target) bool { /// This function returns true if we expect LLVM to lower f16 correctly /// and false if we expect LLVM to crash if it encounters an f16 type, /// or if it produces miscompilations. -fn backendSupportsF16(target: std.Target) bool { +fn backendSupportsF16(target: *const std.Target) bool { return switch (target.cpu.arch) { // https://github.com/llvm/llvm-project/issues/97981 .csky, @@ -12840,7 +12838,7 @@ fn backendSupportsF16(target: std.Target) bool { /// This function returns true if we expect LLVM to lower f128 correctly, /// and false if we expect LLVM to crash if it encounters an f128 type, /// or if it produces miscompilations. -fn backendSupportsF128(target: std.Target) bool { +fn backendSupportsF128(target: *const std.Target) bool { return switch (target.cpu.arch) { // https://github.com/llvm/llvm-project/issues/121122 .amdgcn, @@ -12870,7 +12868,7 @@ fn backendSupportsF128(target: std.Target) bool { /// LLVM does not support all relevant intrinsics for all targets, so we /// may need to manually generate a compiler-rt call. -fn intrinsicsAllowed(scalar_ty: Type, target: std.Target) bool { +fn intrinsicsAllowed(scalar_ty: Type, target: *const std.Target) bool { return switch (scalar_ty.toIntern()) { .f16_type => backendSupportsF16(target), .f80_type => (target.cTypeBitSize(.longdouble) == 80) and backendSupportsF80(target), @@ -12907,7 +12905,7 @@ fn buildAllocaInner( wip: *Builder.WipFunction, llvm_ty: Builder.Type, alignment: Builder.Alignment, - target: std.Target, + target: *const std.Target, ) Allocator.Error!Builder.Value { const address_space = llvmAllocaAddressSpace(target); diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index 5170fa742843..1b99f1bad281 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -185,7 +185,7 @@ pub const Object = struct { /// related to that. error_buffer: ?SpvModule.Decl.Index = null, - pub fn init(gpa: Allocator, target: std.Target) Object { + pub fn init(gpa: Allocator, target: *const std.Target) Object { return .{ .gpa = gpa, .spv = SpvModule.init(gpa, target), diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig index 20bf1b367087..f13d093b0901 100644 --- a/src/codegen/spirv/Module.zig +++ b/src/codegen/spirv/Module.zig @@ -107,7 +107,7 @@ gpa: Allocator, arena: std.heap.ArenaAllocator, /// Target info -target: std.Target, +target: *const std.Target, /// The target SPIR-V version version: spec.Version, @@ -187,7 +187,7 @@ decl_deps: std.ArrayListUnmanaged(Decl.Index) = .empty, /// The list of entry points that should be exported from this module. entry_points: std.AutoArrayHashMapUnmanaged(IdRef, EntryPoint) = .empty, -pub fn init(gpa: Allocator, target: std.Target) Module { +pub fn init(gpa: Allocator, target: *const std.Target) Module { const version_minor: u8 = blk: { // Prefer higher versions if (target.cpu.has(.spirv, .v1_6)) break :blk 6; diff --git a/src/libs/freebsd.zig b/src/libs/freebsd.zig index f6195ffa914e..55d097b71baa 100644 --- a/src/libs/freebsd.zig +++ b/src/libs/freebsd.zig @@ -66,7 +66,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre defer arena_allocator.deinit(); const arena = arena_allocator.allocator(); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; // In all cases in this function, we add the C compiler flags to // cache_exempt_flags rather than extra_flags, because these arguments @@ -407,7 +407,7 @@ pub const BuiltSharedObjects = struct { const all_map_basename = "all.map"; -fn wordDirective(target: std.Target) []const u8 { +fn wordDirective(target: *const std.Target) []const u8 { // Based on its description in the GNU `as` manual, you might assume that `.word` is sized // according to the target word size. But no; that would just make too much sense. return if (target.ptrBitWidth() == 64) ".quad" else ".long"; diff --git a/src/libs/glibc.zig b/src/libs/glibc.zig index 8031827a9d29..da6ee74962b8 100644 --- a/src/libs/glibc.zig +++ b/src/libs/glibc.zig @@ -172,7 +172,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre defer arena_allocator.deinit(); const arena = arena_allocator.allocator(); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const target_ver = target.os.versionRange().gnuLibCVersion().?; const nonshared_stat = target_ver.order(.{ .major = 2, .minor = 32, .patch = 0 }) != .gt; const start_old_init_fini = target_ver.order(.{ .major = 2, .minor = 33, .patch = 0 }) != .gt; @@ -485,7 +485,7 @@ fn add_include_dirs(comp: *Compilation, arena: Allocator, args: *std.ArrayList([ fn add_include_dirs_arch( arena: Allocator, args: *std.ArrayList([]const u8), - target: std.Target, + target: *const std.Target, opt_nptl: ?[]const u8, dir: []const u8, ) error{OutOfMemory}!void { @@ -649,7 +649,7 @@ pub const BuiltSharedObjects = struct { const all_map_basename = "all.map"; -fn wordDirective(target: std.Target) []const u8 { +fn wordDirective(target: *const std.Target) []const u8 { // Based on its description in the GNU `as` manual, you might assume that `.word` is sized // according to the target word size. But no; that would just make too much sense. return if (target.ptrBitWidth() == 64) ".quad" else ".long"; diff --git a/src/libs/libcxx.zig b/src/libs/libcxx.zig index 0009bfe120c8..f26f27732bf9 100644 --- a/src/libs/libcxx.zig +++ b/src/libs/libcxx.zig @@ -121,7 +121,7 @@ pub fn buildLibCxx(comp: *Compilation, prog_node: std.Progress.Node) BuildError! const root_name = "c++"; const output_mode = .Lib; const link_mode = .static; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const cxxabi_include_path = try comp.dirs.zig_lib.join(arena, &.{ "libcxxabi", "include" }); const cxx_include_path = try comp.dirs.zig_lib.join(arena, &.{ "libcxx", "include" }); @@ -314,7 +314,7 @@ pub fn buildLibCxxAbi(comp: *Compilation, prog_node: std.Progress.Node) BuildErr const root_name = "c++abi"; const output_mode = .Lib; const link_mode = .static; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const cxxabi_include_path = try comp.dirs.zig_lib.join(arena, &.{ "libcxxabi", "include" }); const cxx_include_path = try comp.dirs.zig_lib.join(arena, &.{ "libcxx", "include" }); diff --git a/src/libs/libtsan.zig b/src/libs/libtsan.zig index f2cd6831f7d7..36ca5faa251e 100644 --- a/src/libs/libtsan.zig +++ b/src/libs/libtsan.zig @@ -324,7 +324,7 @@ pub fn buildTsan(comp: *Compilation, prog_node: std.Progress.Node) BuildError!vo comp.tsan_lib = crt_file; } -fn addCcArgs(target: std.Target, args: *std.ArrayList([]const u8)) error{OutOfMemory}!void { +fn addCcArgs(target: *const std.Target, args: *std.ArrayList([]const u8)) error{OutOfMemory}!void { try args.appendSlice(&[_][]const u8{ "-nostdinc++", "-fvisibility=hidden", diff --git a/src/libs/libunwind.zig b/src/libs/libunwind.zig index 711d63ebbcb0..430ff597481e 100644 --- a/src/libs/libunwind.zig +++ b/src/libs/libunwind.zig @@ -27,7 +27,7 @@ pub fn buildStaticLib(comp: *Compilation, prog_node: std.Progress.Node) BuildErr const arena = arena_allocator.allocator(); const output_mode = .Lib; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const unwind_tables: std.builtin.UnwindTables = if (target.cpu.arch == .x86 and target.os.tag == .windows) .none else .@"async"; const config = Compilation.Config.resolve(.{ diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig index 9454a9af25c3..c978a651a0f3 100644 --- a/src/libs/mingw.zig +++ b/src/libs/mingw.zig @@ -299,7 +299,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void { var aro_comp = aro.Compilation.init(gpa, std.fs.cwd()); defer aro_comp.deinit(); - aro_comp.target = target; + aro_comp.target = target.*; const include_dir = try comp.dirs.zig_lib.join(arena, &.{ "libc", "mingw", "def-include" }); @@ -373,7 +373,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void { pub fn libExists( allocator: Allocator, - target: std.Target, + target: *const std.Target, zig_lib_directory: Cache.Directory, lib_name: []const u8, ) !bool { @@ -389,7 +389,7 @@ pub fn libExists( /// see if a .def file exists. fn findDef( allocator: Allocator, - target: std.Target, + target: *const std.Target, zig_lib_directory: Cache.Directory, lib_name: []const u8, ) ![]u8 { diff --git a/src/libs/musl.zig b/src/libs/musl.zig index 7c4e71c9744f..b6ef84ac3bdb 100644 --- a/src/libs/musl.zig +++ b/src/libs/musl.zig @@ -193,7 +193,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro .link_libc = false, }); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const arch_name = std.zig.target.muslArchName(target.cpu.arch, target.abi); const time32 = for (time32_compat_arch_list) |time32_compat_arch| { if (mem.eql(u8, arch_name, time32_compat_arch)) break true; diff --git a/src/libs/netbsd.zig b/src/libs/netbsd.zig index fdab27f217f3..38570c43a671 100644 --- a/src/libs/netbsd.zig +++ b/src/libs/netbsd.zig @@ -58,7 +58,7 @@ pub fn buildCrtFile(comp: *Compilation, crt_file: CrtFile, prog_node: std.Progre defer arena_allocator.deinit(); const arena = arena_allocator.allocator(); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const target_version = target.os.version_range.semver.min; // In all cases in this function, we add the C compiler flags to @@ -353,7 +353,7 @@ pub const BuiltSharedObjects = struct { } }; -fn wordDirective(target: std.Target) []const u8 { +fn wordDirective(target: *const std.Target) []const u8 { // Based on its description in the GNU `as` manual, you might assume that `.word` is sized // according to the target word size. But no; that would just make too much sense. return if (target.ptrBitWidth() == 64) ".quad" else ".long"; diff --git a/src/link.zig b/src/link.zig index 29ee0c7b15e4..8833720828de 100644 --- a/src/link.zig +++ b/src/link.zig @@ -1321,7 +1321,7 @@ pub fn doPrelinkTask(comp: *Compilation, task: PrelinkTask) void { const prog_node = comp.link_prog_node.start("Parse Host libc", 0); defer prog_node.end(); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const flags = target_util.libcFullLinkFlags(target); const crt_dir = comp.libc_installation.?.crt_dir.?; const sep = std.fs.path.sep_str; @@ -1670,7 +1670,7 @@ pub fn hashInputs(man: *Cache.Manifest, link_inputs: []const Input) !void { pub fn resolveInputs( gpa: Allocator, arena: Allocator, - target: std.Target, + target: *const std.Target, /// This function mutates this array but does not take ownership. /// Allocated with `gpa`. unresolved_inputs: *std.ArrayListUnmanaged(UnresolvedInput), @@ -1914,7 +1914,7 @@ fn resolveLibInput( ld_script_bytes: *std.ArrayListUnmanaged(u8), lib_directory: Directory, name_query: UnresolvedInput.NameQuery, - target: std.Target, + target: *const std.Target, link_mode: std.builtin.LinkMode, color: std.zig.Color, ) Allocator.Error!ResolveLibInputResult { @@ -2028,7 +2028,7 @@ fn resolvePathInput( resolved_inputs: *std.ArrayListUnmanaged(Input), /// Allocated via `gpa`. ld_script_bytes: *std.ArrayListUnmanaged(u8), - target: std.Target, + target: *const std.Target, pq: UnresolvedInput.PathQuery, color: std.zig.Color, ) Allocator.Error!?ResolveLibInputResult { @@ -2070,7 +2070,7 @@ fn resolvePathInputLib( resolved_inputs: *std.ArrayListUnmanaged(Input), /// Allocated via `gpa`. ld_script_bytes: *std.ArrayListUnmanaged(u8), - target: std.Target, + target: *const std.Target, pq: UnresolvedInput.PathQuery, link_mode: std.builtin.LinkMode, color: std.zig.Color, diff --git a/src/link/C.zig b/src/link/C.zig index f3465055b862..1ea130f6b1d3 100644 --- a/src/link/C.zig +++ b/src/link/C.zig @@ -116,7 +116,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*C { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .c); const optimize_mode = comp.root_mod.optimize_mode; const use_lld = build_options.have_llvm and comp.config.use_lld; @@ -331,7 +331,7 @@ pub fn updateLineNumber(self: *C, pt: Zcu.PerThread, ti_id: InternPool.TrackedIn _ = ti_id; } -fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) { +fn abiDefines(self: *C, target: *const std.Target) !std.ArrayList(u8) { const gpa = self.base.comp.gpa; var defines = std.ArrayList(u8).init(gpa); errdefer defines.deinit(); diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 0e00229b78e0..d774f14bf634 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -208,7 +208,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Coff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .coff); const optimize_mode = comp.root_mod.optimize_mode; const output_mode = comp.config.output_mode; @@ -1328,7 +1328,7 @@ fn updateNavCode( log.debug("updateNavCode {} 0x{x}", .{ nav.fqn.fmt(ip), nav_index }); - const target = zcu.navFileScope(nav_index).mod.?.resolved_target.result; + const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; const required_alignment = switch (pt.navAlignment(nav_index)) { .none => target_util.defaultFunctionAlignment(target), else => |a| a.maxStrict(target_util.minFunctionAlignment(target)), @@ -2153,7 +2153,7 @@ fn writeDataDirectoriesHeaders(coff: *Coff) !void { } fn writeHeader(coff: *Coff) !void { - const target = coff.base.comp.root_mod.resolved_target.result; + const target = &coff.base.comp.root_mod.resolved_target.result; const gpa = coff.base.comp.gpa; var buffer = std.ArrayList(u8).init(gpa); defer buffer.deinit(); @@ -2800,7 +2800,7 @@ pub const Relocation = struct { .ptr_width = coff.ptr_width, }; - const target = coff.base.comp.root_mod.resolved_target.result; + const target = &coff.base.comp.root_mod.resolved_target.result; switch (target.cpu.arch) { .aarch64 => reloc.resolveAarch64(ctx), .x86, .x86_64 => reloc.resolveX86(ctx), diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig index 0afe10ef03db..605d1d23a491 100644 --- a/src/link/Dwarf.zig +++ b/src/link/Dwarf.zig @@ -92,7 +92,7 @@ const DebugFrame = struct { }; fn headerBytes(dwarf: *Dwarf) u32 { - const target = dwarf.bin_file.comp.root_mod.resolved_target.result; + const target = &dwarf.bin_file.comp.root_mod.resolved_target.result; return @intCast(switch (dwarf.debug_frame.header.format) { .none => return 0, .debug_frame => dwarf.unitLengthBytes() + dwarf.sectionOffsetBytes() + 1 + "\x00".len + 1 + 1, @@ -2140,7 +2140,7 @@ fn padToIdeal(actual_size: anytype) @TypeOf(actual_size) { pub fn init(lf: *link.File, format: DW.Format) Dwarf { const comp = lf.comp; const gpa = comp.gpa; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; return .{ .gpa = gpa, .bin_file = lf, @@ -2573,7 +2573,7 @@ fn initWipNavInner( try wip_nav.infoAddrSym(sym_index, 0); wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len); try diw.writeInt(u32, 0, dwarf.endian); - const target = mod.resolved_target.result; + const target = &mod.resolved_target.result; try uleb128(diw, switch (nav.status.fully_resolved.alignment) { .none => target_info.defaultFunctionAlignment(target), else => |a| a.maxStrict(target_info.minFunctionAlignment(target)), @@ -4529,7 +4529,7 @@ pub fn flush(dwarf: *Dwarf, pt: Zcu.PerThread) FlushError!void { dwarf.debug_aranges.section.dirty = false; } if (dwarf.debug_frame.section.dirty) { - const target = dwarf.bin_file.comp.root_mod.resolved_target.result; + const target = &dwarf.bin_file.comp.root_mod.resolved_target.result; switch (dwarf.debug_frame.header.format) { .none => {}, .debug_frame => unreachable, diff --git a/src/link/Elf.zig b/src/link/Elf.zig index 0beea0d9e7d5..f4e903aa6a45 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -196,7 +196,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Elf { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .elf); const use_llvm = comp.config.use_llvm; @@ -1073,7 +1073,7 @@ fn parseObject(self: *Elf, obj: link.Input.Object) !void { const gpa = self.base.comp.gpa; const diags = &self.base.comp.link_diags; - const target = self.base.comp.root_mod.resolved_target.result; + const target = &self.base.comp.root_mod.resolved_target.result; const debug_fmt_strip = self.base.comp.config.debug_format == .strip; const default_sym_version = self.default_sym_version; const file_handles = &self.file_handles; @@ -1104,7 +1104,7 @@ fn parseArchive( diags: *Diags, file_handles: *std.ArrayListUnmanaged(File.Handle), files: *std.MultiArrayList(File.Entry), - target: std.Target, + target: *const std.Target, debug_fmt_strip: bool, default_sym_version: elf.Versym, objects: *std.ArrayListUnmanaged(File.Index), @@ -1139,7 +1139,7 @@ fn parseDso( dso: link.Input.Dso, shared_objects: *std.StringArrayHashMapUnmanaged(File.Index), files: *std.MultiArrayList(File.Entry), - target: std.Target, + target: *const std.Target, ) !void { const tracy = trace(@src()); defer tracy.end(); @@ -4121,8 +4121,8 @@ pub fn lsearch(comptime T: type, haystack: []const T, predicate: anytype) usize return i; } -pub fn getTarget(self: Elf) std.Target { - return self.base.comp.root_mod.resolved_target.result; +pub fn getTarget(self: *const Elf) *const std.Target { + return &self.base.comp.root_mod.resolved_target.result; } fn requiresThunks(self: Elf) bool { diff --git a/src/link/Elf/Object.zig b/src/link/Elf/Object.zig index dcea9fe402e6..4d5b5378c4a8 100644 --- a/src/link/Elf/Object.zig +++ b/src/link/Elf/Object.zig @@ -69,7 +69,7 @@ pub fn parse( /// For error reporting purposes only. path: Path, handle: fs.File, - target: std.Target, + target: *const std.Target, debug_fmt_strip: bool, default_sym_version: elf.Versym, ) !void { @@ -98,7 +98,7 @@ pub fn parseCommon( diags: *Diags, path: Path, handle: fs.File, - target: std.Target, + target: *const std.Target, ) !void { const offset = if (self.archive) |ar| ar.offset else 0; const file_size = (try handle.stat()).size; @@ -182,7 +182,7 @@ pub fn parseCommon( pub fn validateEFlags( diags: *Diags, path: Path, - target: std.Target, + target: *const std.Target, e_flags: elf.Word, ) !void { switch (target.cpu.arch) { @@ -263,7 +263,7 @@ fn initAtoms( path: Path, handle: fs.File, debug_fmt_strip: bool, - target: std.Target, + target: *const std.Target, ) !void { const shdrs = self.shdrs.items; try self.atoms.ensureTotalCapacityPrecise(gpa, shdrs.len); @@ -420,7 +420,7 @@ fn parseEhFrame( gpa: Allocator, handle: fs.File, shndx: u32, - target: std.Target, + target: *const std.Target, ) !void { const relocs_shndx = for (self.shdrs.items, 0..) |shdr, i| switch (shdr.sh_type) { elf.SHT_RELA => if (shdr.sh_info == shndx) break @as(u32, @intCast(i)), diff --git a/src/link/Elf/SharedObject.zig b/src/link/Elf/SharedObject.zig index ac3b3857a1c9..30def4429bed 100644 --- a/src/link/Elf/SharedObject.zig +++ b/src/link/Elf/SharedObject.zig @@ -96,7 +96,7 @@ pub fn parseHeader( file_path: Path, fs_file: std.fs.File, stat: Stat, - target: std.Target, + target: *const std.Target, ) !Header { var ehdr: elf.Elf64_Ehdr = undefined; { diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig index 71b42819e290..d47488975c3e 100644 --- a/src/link/Elf/ZigObject.zig +++ b/src/link/Elf/ZigObject.zig @@ -1271,7 +1271,7 @@ fn updateNavCode( log.debug("updateNavCode {}({d})", .{ nav.fqn.fmt(ip), nav_index }); - const target = zcu.navFileScope(nav_index).mod.?.resolved_target.result; + const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; const required_alignment = switch (pt.navAlignment(nav_index)) { .none => target_util.defaultFunctionAlignment(target), else => |a| a.maxStrict(target_util.minFunctionAlignment(target)), diff --git a/src/link/Goff.zig b/src/link/Goff.zig index 1f4a7a4d3095..9a39e4b9f8df 100644 --- a/src/link/Goff.zig +++ b/src/link/Goff.zig @@ -26,7 +26,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Goff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const use_lld = build_options.have_llvm and comp.config.use_lld; const use_llvm = comp.config.use_llvm; @@ -59,7 +59,7 @@ pub fn open( emit: Path, options: link.File.OpenOptions, ) !*Goff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .goff); return createEmpty(arena, comp, emit, options); } diff --git a/src/link/Lld.zig b/src/link/Lld.zig index 4ea809428e58..45ef112dc474 100644 --- a/src/link/Lld.zig +++ b/src/link/Lld.zig @@ -30,7 +30,7 @@ const Coff = struct { dllmain_crt_startup: bool, }, fn init(comp: *Compilation, options: link.File.OpenOptions) !Coff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const output_mode = comp.config.output_mode; return .{ .image_base = options.image_base orelse switch (output_mode) { @@ -103,7 +103,7 @@ pub const Elf = struct { fn init(comp: *Compilation, options: link.File.OpenOptions) !Elf { const PtrWidth = enum { p32, p64 }; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const output_mode = comp.config.output_mode; const is_dyn_lib = output_mode == .Lib and comp.config.link_mode == .dynamic; const ptr_width: PtrWidth = switch (target.ptrBitWidth()) { @@ -202,7 +202,7 @@ pub fn createEmpty( emit: Cache.Path, options: link.File.OpenOptions, ) !*Lld { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const output_mode = comp.config.output_mode; const optimize_mode = comp.root_mod.optimize_mode; const is_native_os = comp.root_mod.resolved_target.is_native_os; @@ -342,7 +342,7 @@ fn linkAsArchive(lld: *Lld, arena: Allocator) !void { const llvm_bindings = @import("../codegen/llvm/bindings.zig"); const llvm = @import("../codegen/llvm.zig"); - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; llvm.initializeLLVMTarget(target.cpu.arch); const bad = llvm_bindings.WriteArchive( full_out_path_z, @@ -374,7 +374,7 @@ fn coffLink(lld: *Lld, arena: Allocator) !void { const is_dyn_lib = comp.config.link_mode == .dynamic and is_lib; const is_exe_or_dyn_lib = is_dyn_lib or comp.config.output_mode == .Exe; const link_in_crt = comp.config.link_libc and is_exe_or_dyn_lib; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const optimize_mode = comp.root_mod.optimize_mode; const entry_name: ?[]const u8 = switch (coff.entry) { // This logic isn't quite right for disabled or enabled. No point in fixing it @@ -811,7 +811,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void { const is_dyn_lib = link_mode == .dynamic and is_lib; const is_exe_or_dyn_lib = is_dyn_lib or output_mode == .Exe; const have_dynamic_linker = link_mode == .dynamic and is_exe_or_dyn_lib; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const compiler_rt_path: ?Cache.Path = blk: { if (comp.compiler_rt_lib) |x| break :blk x.full_object_path; if (comp.compiler_rt_obj) |x| break :blk x.full_object_path; @@ -1281,7 +1281,7 @@ fn elfLink(lld: *Lld, arena: Allocator) !void { try spawnLld(comp, arena, argv.items); } } -fn getLDMOption(target: std.Target) ?[]const u8 { +fn getLDMOption(target: *const std.Target) ?[]const u8 { // This should only return emulations understood by LLD's parseEmulation(). return switch (target.cpu.arch) { .aarch64 => switch (target.os.tag) { @@ -1364,7 +1364,7 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void { const shared_memory = comp.config.shared_memory; const export_memory = comp.config.export_memory; const import_memory = comp.config.import_memory; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const base = &lld.base; const wasm = &lld.ofmt.wasm; diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 3f3a94bee71a..948b7022a280 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -163,7 +163,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*MachO { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .macho); const gpa = comp.gpa; @@ -3545,8 +3545,8 @@ pub fn markDirty(self: *MachO, sect_index: u8) void { } } -pub fn getTarget(self: MachO) std.Target { - return self.base.comp.root_mod.resolved_target.result; +pub fn getTarget(self: *const MachO) *const std.Target { + return &self.base.comp.root_mod.resolved_target.result; } /// XNU starting with Big Sur running on arm64 is caching inodes of running binaries. @@ -4233,7 +4233,7 @@ pub const Platform = struct { } } - pub fn fromTarget(target: std.Target) Platform { + pub fn fromTarget(target: *const std.Target) Platform { return .{ .os_tag = target.os.tag, .abi = target.abi, diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig index f9ecdc6fb50d..1d7c2ceb1741 100644 --- a/src/link/MachO/ZigObject.zig +++ b/src/link/MachO/ZigObject.zig @@ -948,7 +948,7 @@ fn updateNavCode( log.debug("updateNavCode {} 0x{x}", .{ nav.fqn.fmt(ip), nav_index }); - const target = zcu.navFileScope(nav_index).mod.?.resolved_target.result; + const target = &zcu.navFileScope(nav_index).mod.?.resolved_target.result; const required_alignment = switch (pt.navAlignment(nav_index)) { .none => target_util.defaultFunctionAlignment(target), else => |a| a.maxStrict(target_util.minFunctionAlignment(target)), diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig index c99ebb81bb78..ce5e65f2c236 100644 --- a/src/link/Plan9.zig +++ b/src/link/Plan9.zig @@ -184,7 +184,7 @@ pub const Atom = struct { // asserts that self.got_index != null pub fn getOffsetTableAddress(self: Atom, plan9: *Plan9) u64 { - const target = plan9.base.comp.root_mod.resolved_target.result; + const target = &plan9.base.comp.root_mod.resolved_target.result; const ptr_bytes = @divExact(target.ptrBitWidth(), 8); const got_addr = plan9.bases.data; const got_index = self.got_index.?; @@ -278,7 +278,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Plan9 { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const gpa = comp.gpa; const optimize_mode = comp.root_mod.optimize_mode; const output_mode = comp.config.output_mode; @@ -394,7 +394,7 @@ pub fn updateFunc( const zcu = pt.zcu; const gpa = zcu.gpa; - const target = self.base.comp.root_mod.resolved_target.result; + const target = &self.base.comp.root_mod.resolved_target.result; const func = zcu.funcInfo(func_index); const atom_idx = try self.seeNav(pt, func.owner_nav); @@ -583,7 +583,7 @@ pub fn flush( const comp = self.base.comp; const diags = &comp.link_diags; const gpa = comp.gpa; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; switch (comp.config.output_mode) { .Exe => {}, @@ -1153,7 +1153,7 @@ pub fn open( emit: Path, options: link.File.OpenOptions, ) !*Plan9 { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const use_lld = build_options.have_llvm and comp.config.use_lld; const use_llvm = comp.config.use_llvm; diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig index bafefccfc0e4..1e01a50a6c9f 100644 --- a/src/link/SpirV.zig +++ b/src/link/SpirV.zig @@ -58,7 +58,7 @@ pub fn createEmpty( options: link.File.OpenOptions, ) !*SpirV { const gpa = comp.gpa; - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(!comp.config.use_lld); // Caught by Compilation.Config.resolve assert(!comp.config.use_llvm); // Caught by Compilation.Config.resolve diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index eda755298670..5f98771dcf5e 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -2943,7 +2943,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Wasm { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .wasm); const use_llvm = comp.config.use_llvm; diff --git a/src/link/Xcoff.zig b/src/link/Xcoff.zig index fd143713ffcf..127ff1891745 100644 --- a/src/link/Xcoff.zig +++ b/src/link/Xcoff.zig @@ -26,7 +26,7 @@ pub fn createEmpty( emit: Path, options: link.File.OpenOptions, ) !*Xcoff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; const use_lld = build_options.have_llvm and comp.config.use_lld; const use_llvm = comp.config.use_llvm; @@ -59,7 +59,7 @@ pub fn open( emit: Path, options: link.File.OpenOptions, ) !*Xcoff { - const target = comp.root_mod.resolved_target.result; + const target = &comp.root_mod.resolved_target.result; assert(target.ofmt == .xcoff); return createEmpty(arena, comp, emit, options); } diff --git a/src/main.zig b/src/main.zig index 00954b2564ab..e974621e5e92 100644 --- a/src/main.zig +++ b/src/main.zig @@ -340,7 +340,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void { dev.check(.targets_command); const host = std.zig.resolveTargetQueryOrFatal(.{}); const stdout = io.getStdOut().writer(); - return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, host); + return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, &host); } else if (mem.eql(u8, cmd, "version")) { dev.check(.version_command); try std.io.getStdOut().writeAll(build_options.version ++ "\n"); @@ -3086,7 +3086,7 @@ fn buildOutputType( else => main_mod, }; - const target = main_mod.resolved_target.result; + const target = &main_mod.resolved_target.result; if (target.cpu.arch == .arc or target.cpu.arch.isNvptx()) { if (emit_bin != .no and create_module.resolved_options.use_llvm) { @@ -3655,7 +3655,7 @@ fn buildOutputType( test_exec_args.items, self_exe_path, arg_mode, - &target, + target, &comp_destroyed, all_args, runtime_args_start, @@ -3800,12 +3800,12 @@ fn createModule( // This block is for initializing the fields of // `Compilation.Config.Options` that require knowledge of the // target (which was just now resolved for the root module above). - const resolved_target = cli_mod.inherited.resolved_target.?; - create_module.opts.resolved_target = resolved_target; + const resolved_target = &cli_mod.inherited.resolved_target.?; + create_module.opts.resolved_target = resolved_target.*; create_module.opts.root_optimize_mode = cli_mod.inherited.optimize_mode; create_module.opts.root_strip = cli_mod.inherited.strip; create_module.opts.root_error_tracing = cli_mod.inherited.error_tracing; - const target = resolved_target.result; + const target = &resolved_target.result; // First, remove libc, libc++, and compiler_rt libraries from the system libraries list. // We need to know whether the set of system libraries contains anything besides these @@ -6482,7 +6482,7 @@ fn warnAboutForeignBinaries( const host_query: std.Target.Query = .{}; const host_target = std.zig.resolveTargetQueryOrFatal(host_query); - switch (std.zig.system.getExternalExecutor(host_target, target, .{ .link_libc = link_libc })) { + switch (std.zig.system.getExternalExecutor(&host_target, target, .{ .link_libc = link_libc })) { .native => return, .rosetta => { const host_name = try host_target.zigTriple(arena); diff --git a/src/print_targets.zig b/src/print_targets.zig index dc292c979d40..96371eb1ee8d 100644 --- a/src/print_targets.zig +++ b/src/print_targets.zig @@ -16,7 +16,7 @@ pub fn cmdTargets( args: []const []const u8, /// Output stream stdout: anytype, - native_target: Target, + native_target: *const Target, ) !void { _ = args; var zig_lib_directory = introspect.findZigLibDir(allocator) catch |err| { diff --git a/src/target.zig b/src/target.zig index 1d846da87966..f96984903780 100644 --- a/src/target.zig +++ b/src/target.zig @@ -9,7 +9,7 @@ const Feature = @import("Zcu.zig").Feature; pub const default_stack_protector_buffer_size = 4; -pub fn cannotDynamicLink(target: std.Target) bool { +pub fn cannotDynamicLink(target: *const std.Target) bool { return switch (target.os.tag) { .freestanding => true, else => target.cpu.arch.isSpirV(), @@ -19,15 +19,15 @@ pub fn cannotDynamicLink(target: std.Target) bool { /// On Darwin, we always link libSystem which contains libc. /// Similarly on FreeBSD and NetBSD we always link system libc /// since this is the stable syscall interface. -pub fn osRequiresLibC(target: std.Target) bool { +pub fn osRequiresLibC(target: *const std.Target) bool { return target.os.requiresLibC(); } -pub fn libCNeedsLibUnwind(target: std.Target, link_mode: std.builtin.LinkMode) bool { +pub fn libCNeedsLibUnwind(target: *const std.Target, link_mode: std.builtin.LinkMode) bool { return target.isGnuLibC() and link_mode == .static; } -pub fn libCxxNeedsLibUnwind(target: std.Target) bool { +pub fn libCxxNeedsLibUnwind(target: *const std.Target) bool { return switch (target.os.tag) { .macos, .ios, @@ -44,14 +44,14 @@ pub fn libCxxNeedsLibUnwind(target: std.Target) bool { } /// This function returns whether non-pic code is completely invalid on the given target. -pub fn requiresPIC(target: std.Target, linking_libc: bool) bool { +pub fn requiresPIC(target: *const std.Target, linking_libc: bool) bool { return target.abi.isAndroid() or target.os.tag == .windows or target.os.tag == .uefi or osRequiresLibC(target) or (linking_libc and target.isGnuLibC()); } -pub fn picLevel(target: std.Target) u32 { +pub fn picLevel(target: *const std.Target) u32 { // MIPS always uses PIC level 1; other platforms vary in their default PIC levels, but they // support both level 1 and 2, in which case we prefer 2. return if (target.cpu.arch.isMIPS()) 1 else 2; @@ -59,7 +59,7 @@ pub fn picLevel(target: std.Target) u32 { /// This is not whether the target supports Position Independent Code, but whether the -fPIC /// C compiler argument is valid to Clang. -pub fn supports_fpic(target: std.Target) bool { +pub fn supports_fpic(target: *const std.Target) bool { return switch (target.os.tag) { .windows, .uefi, @@ -68,12 +68,12 @@ pub fn supports_fpic(target: std.Target) bool { }; } -pub fn alwaysSingleThreaded(target: std.Target) bool { +pub fn alwaysSingleThreaded(target: *const std.Target) bool { _ = target; return false; } -pub fn defaultSingleThreaded(target: std.Target) bool { +pub fn defaultSingleThreaded(target: *const std.Target) bool { switch (target.cpu.arch) { .wasm32, .wasm64 => return true, else => {}, @@ -85,7 +85,7 @@ pub fn defaultSingleThreaded(target: std.Target) bool { return false; } -pub fn hasValgrindSupport(target: std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn hasValgrindSupport(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { // We can't currently output the necessary Valgrind client request assembly when using the C // backend and compiling with an MSVC-like compiler. const ofmt_c_msvc = (target.abi == .msvc or target.abi == .itanium) and target.ofmt == .c; @@ -133,7 +133,7 @@ pub fn hasValgrindSupport(target: std.Target, backend: std.builtin.CompilerBacke /// The set of targets that LLVM has non-experimental support for. /// Used to select between LLVM backend and self-hosted backend when compiling in /// release modes. -pub fn hasLlvmSupport(target: std.Target, ofmt: std.Target.ObjectFormat) bool { +pub fn hasLlvmSupport(target: *const std.Target, ofmt: std.Target.ObjectFormat) bool { switch (ofmt) { // LLVM does not support these object formats: .c, @@ -221,7 +221,7 @@ pub fn hasLldSupport(ofmt: std.Target.ObjectFormat) bool { /// Used to select between LLVM backend and self-hosted backend when compiling in /// debug mode. A given target should only return true here if it is passing greater /// than or equal to the number of behavior tests as the respective LLVM backend. -pub fn selfHostedBackendIsAsRobustAsLlvm(target: std.Target) bool { +pub fn selfHostedBackendIsAsRobustAsLlvm(target: *const std.Target) bool { if (target.cpu.arch.isSpirV()) return true; if (target.cpu.arch == .x86_64 and target.ptrBitWidth() == 64) return switch (target.ofmt) { .elf, .macho => true, @@ -230,12 +230,12 @@ pub fn selfHostedBackendIsAsRobustAsLlvm(target: std.Target) bool { return false; } -pub fn supportsStackProbing(target: std.Target) bool { +pub fn supportsStackProbing(target: *const std.Target) bool { return target.os.tag != .windows and target.os.tag != .uefi and (target.cpu.arch == .x86 or target.cpu.arch == .x86_64); } -pub fn supportsStackProtector(target: std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsStackProtector(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { switch (target.os.tag) { .plan9 => return false, else => {}, @@ -250,20 +250,20 @@ pub fn supportsStackProtector(target: std.Target, backend: std.builtin.CompilerB }; } -pub fn clangSupportsStackProtector(target: std.Target) bool { +pub fn clangSupportsStackProtector(target: *const std.Target) bool { return switch (target.cpu.arch) { .spirv, .spirv32, .spirv64 => return false, else => true, }; } -pub fn libcProvidesStackProtector(target: std.Target) bool { +pub fn libcProvidesStackProtector(target: *const std.Target) bool { return !target.isMinGW() and target.os.tag != .wasi and !target.cpu.arch.isSpirV(); } /// Returns true if `@returnAddress()` is supported by the target and has a /// reasonably performant implementation for the requested optimization mode. -pub fn supportsReturnAddress(target: std.Target, optimize: std.builtin.OptimizeMode) bool { +pub fn supportsReturnAddress(target: *const std.Target, optimize: std.builtin.OptimizeMode) bool { return switch (target.cpu.arch) { // Emscripten currently implements `emscripten_return_address()` by calling // out into JavaScript and parsing a stack trace, which introduces significant @@ -299,7 +299,7 @@ pub fn classifyCompilerRtLibName(name: []const u8) CompilerRtClassification { return .none; } -pub fn hasDebugInfo(target: std.Target) bool { +pub fn hasDebugInfo(target: *const std.Target) bool { return switch (target.cpu.arch) { // TODO: We should make newer PTX versions depend on older ones so we'd just check `ptx75`. .nvptx, .nvptx64 => target.cpu.hasAny(.nvptx, &.{ @@ -321,7 +321,7 @@ pub fn hasDebugInfo(target: std.Target) bool { }; } -pub fn defaultCompilerRtOptimizeMode(target: std.Target) std.builtin.OptimizeMode { +pub fn defaultCompilerRtOptimizeMode(target: *const std.Target) std.builtin.OptimizeMode { if (target.cpu.arch.isWasm() and target.os.tag == .freestanding) { return .ReleaseSmall; } else { @@ -329,7 +329,7 @@ pub fn defaultCompilerRtOptimizeMode(target: std.Target) std.builtin.OptimizeMod } } -pub fn canBuildLibCompilerRt(target: std.Target, use_llvm: bool, have_llvm: bool) bool { +pub fn canBuildLibCompilerRt(target: *const std.Target, use_llvm: bool, have_llvm: bool) bool { switch (target.os.tag) { .plan9 => return false, else => {}, @@ -342,12 +342,15 @@ pub fn canBuildLibCompilerRt(target: std.Target, use_llvm: bool, have_llvm: bool } return switch (zigBackend(target, use_llvm)) { .stage2_llvm => true, - .stage2_x86_64 => if (target.ofmt == .elf or target.ofmt == .macho) true else have_llvm, + .stage2_x86_64 => switch (target.ofmt) { + .elf, .macho => true, + else => have_llvm, + }, else => have_llvm, }; } -pub fn canBuildLibUbsanRt(target: std.Target) bool { +pub fn canBuildLibUbsanRt(target: *const std.Target) bool { switch (target.cpu.arch) { .spirv, .spirv32, .spirv64 => return false, // Remove this once https://github.com/ziglang/zig/issues/23715 is fixed @@ -356,7 +359,7 @@ pub fn canBuildLibUbsanRt(target: std.Target) bool { } } -pub fn hasRedZone(target: std.Target) bool { +pub fn hasRedZone(target: *const std.Target) bool { return switch (target.cpu.arch) { .aarch64, .aarch64_be, @@ -372,7 +375,7 @@ pub fn hasRedZone(target: std.Target) bool { }; } -pub fn libcFullLinkFlags(target: std.Target) []const []const u8 { +pub fn libcFullLinkFlags(target: *const std.Target) []const []const u8 { // The linking order of these is significant and should match the order other // c compilers such as gcc or clang use. const result: []const []const u8 = switch (target.os.tag) { @@ -389,14 +392,14 @@ pub fn libcFullLinkFlags(target: std.Target) []const []const u8 { return result; } -pub fn clangMightShellOutForAssembly(target: std.Target) bool { +pub fn clangMightShellOutForAssembly(target: *const std.Target) bool { // Clang defaults to using the system assembler in some cases. return target.cpu.arch.isNvptx() or target.cpu.arch == .xcore; } /// Each backend architecture in Clang has a different codepath which may or may not /// support an -mcpu flag. -pub fn clangAssemblerSupportsMcpuArg(target: std.Target) bool { +pub fn clangAssemblerSupportsMcpuArg(target: *const std.Target) bool { return switch (target.cpu.arch) { .arm, .armeb, .thumb, .thumbeb => true, else => false, @@ -405,7 +408,7 @@ pub fn clangAssemblerSupportsMcpuArg(target: std.Target) bool { /// Some experimental or poorly-maintained LLVM targets do not properly process CPU models in their /// Clang driver code. For these, we should omit the `-Xclang -target-cpu -Xclang ` flags. -pub fn clangSupportsTargetCpuArg(target: std.Target) bool { +pub fn clangSupportsTargetCpuArg(target: *const std.Target) bool { return switch (target.cpu.arch) { .arc, .msp430, @@ -417,7 +420,7 @@ pub fn clangSupportsTargetCpuArg(target: std.Target) bool { }; } -pub fn clangSupportsFloatAbiArg(target: std.Target) bool { +pub fn clangSupportsFloatAbiArg(target: *const std.Target) bool { return switch (target.cpu.arch) { .arm, .armeb, @@ -442,7 +445,7 @@ pub fn clangSupportsFloatAbiArg(target: std.Target) bool { }; } -pub fn clangSupportsNoImplicitFloatArg(target: std.Target) bool { +pub fn clangSupportsNoImplicitFloatArg(target: *const std.Target) bool { return switch (target.cpu.arch) { .aarch64, .aarch64_be, @@ -459,7 +462,7 @@ pub fn clangSupportsNoImplicitFloatArg(target: std.Target) bool { }; } -pub fn defaultUnwindTables(target: std.Target, libunwind: bool, libtsan: bool) std.builtin.UnwindTables { +pub fn defaultUnwindTables(target: *const std.Target, libunwind: bool, libtsan: bool) std.builtin.UnwindTables { if (target.os.tag == .windows) { // The old 32-bit x86 variant of SEH doesn't use tables. return if (target.cpu.arch != .x86) .@"async" else .none; @@ -472,7 +475,7 @@ pub fn defaultUnwindTables(target: std.Target, libunwind: bool, libtsan: bool) s } pub fn defaultAddressSpace( - target: std.Target, + target: *const std.Target, context: enum { /// Query the default address space for global constant values. global_constant, @@ -492,7 +495,7 @@ pub fn defaultAddressSpace( /// Returns true if pointers in `from` can be converted to a pointer in `to`. pub fn addrSpaceCastIsValid( - target: std.Target, + target: *const std.Target, from: AddressSpace, to: AddressSpace, ) bool { @@ -512,7 +515,7 @@ pub fn addrSpaceCastIsValid( /// a number of restrictions on usage of such pointers. For example, a logical pointer may not be /// part of a merge (result of a branch) and may not be stored in memory at all. This function returns /// for a particular architecture and address space wether such pointers are logical. -pub fn arePointersLogical(target: std.Target, as: AddressSpace) bool { +pub fn arePointersLogical(target: *const std.Target, as: AddressSpace) bool { if (target.os.tag != .vulkan) return false; return switch (as) { @@ -537,7 +540,7 @@ pub fn arePointersLogical(target: std.Target, as: AddressSpace) bool { }; } -pub fn isDynamicAMDGCNFeature(target: std.Target, feature: std.Target.Cpu.Feature) bool { +pub fn isDynamicAMDGCNFeature(target: *const std.Target, feature: std.Target.Cpu.Feature) bool { if (target.cpu.arch != .amdgcn) return false; const sramecc_only = &[_]*const std.Target.Cpu.Model{ @@ -585,7 +588,7 @@ pub fn isDynamicAMDGCNFeature(target: std.Target, feature: std.Target.Cpu.Featur return false; } -pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 { +pub fn llvmMachineAbi(target: *const std.Target) ?[:0]const u8 { // LLD does not support ELFv1. Rather than having LLVM produce ELFv1 code and then linking it // into a broken ELFv2 binary, just force LLVM to use ELFv2 as well. This will break when glibc // is linked as glibc only supports ELFv2 for little endian, but there's nothing we can do about @@ -642,7 +645,7 @@ pub fn llvmMachineAbi(target: std.Target) ?[:0]const u8 { /// This function returns 1 if function alignment is not observable or settable. Note that this /// value will not necessarily match the backend's default function alignment (e.g. for LLVM). -pub fn defaultFunctionAlignment(target: std.Target) Alignment { +pub fn defaultFunctionAlignment(target: *const std.Target) Alignment { // Overrides of the minimum for performance. return switch (target.cpu.arch) { .csky, @@ -669,7 +672,7 @@ pub fn defaultFunctionAlignment(target: std.Target) Alignment { } /// This function returns 1 if function alignment is not observable or settable. -pub fn minFunctionAlignment(target: std.Target) Alignment { +pub fn minFunctionAlignment(target: *const std.Target) Alignment { return switch (target.cpu.arch) { .riscv32, .riscv64, @@ -712,7 +715,7 @@ pub fn minFunctionAlignment(target: std.Target) Alignment { }; } -pub fn supportsFunctionAlignment(target: std.Target) bool { +pub fn supportsFunctionAlignment(target: *const std.Target) bool { return switch (target.cpu.arch) { .nvptx, .nvptx64, @@ -726,7 +729,7 @@ pub fn supportsFunctionAlignment(target: std.Target) bool { }; } -pub fn functionPointerMask(target: std.Target) ?u64 { +pub fn functionPointerMask(target: *const std.Target) ?u64 { // 32-bit Arm uses the LSB to mean that the target function contains Thumb code. // MIPS uses the LSB to mean that the target function contains MIPS16/microMIPS code. return if (target.cpu.arch.isArm() or target.cpu.arch.isMIPS32()) @@ -737,7 +740,7 @@ pub fn functionPointerMask(target: std.Target) ?u64 { null; } -pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsTailCall(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { switch (backend) { .stage2_llvm => return @import("codegen/llvm.zig").supportsTailCall(target), .stage2_c => return true, @@ -745,7 +748,7 @@ pub fn supportsTailCall(target: std.Target, backend: std.builtin.CompilerBackend } } -pub fn supportsThreads(target: std.Target, backend: std.builtin.CompilerBackend) bool { +pub fn supportsThreads(target: *const std.Target, backend: std.builtin.CompilerBackend) bool { return switch (backend) { .stage2_powerpc => true, .stage2_x86_64 => target.ofmt == .macho or target.ofmt == .elf, @@ -804,7 +807,7 @@ pub fn fnCallConvAllowsZigTypes(cc: std.builtin.CallingConvention) bool { }; } -pub fn zigBackend(target: std.Target, use_llvm: bool) std.builtin.CompilerBackend { +pub fn zigBackend(target: *const std.Target, use_llvm: bool) std.builtin.CompilerBackend { if (use_llvm) return .stage2_llvm; if (target.ofmt == .c) return .stage2_c; return switch (target.cpu.arch) { diff --git a/test/link/macho.zig b/test/link/macho.zig index ed83000c08d6..e5e38f88e085 100644 --- a/test/link/macho.zig +++ b/test/link/macho.zig @@ -864,7 +864,7 @@ fn testLayout(b: *Build, opts: Options) *Step { fn testLinkDirectlyCppTbd(b: *Build, opts: Options) *Step { const test_step = addTestStep(b, "link-directly-cpp-tbd", opts); - const sdk = std.zig.system.darwin.getSdk(b.allocator, opts.target.result) orelse + const sdk = std.zig.system.darwin.getSdk(b.allocator, &opts.target.result) orelse @panic("macOS SDK is required to run the test"); const exe = addExecutable(b, opts, .{ diff --git a/test/src/Cases.zig b/test/src/Cases.zig index 4c8eed85b63e..d8fe74c93c29 100644 --- a/test/src/Cases.zig +++ b/test/src/Cases.zig @@ -433,7 +433,7 @@ fn addFromDirInner( // Cross-product to get all possible test combinations for (targets) |target_query| { const resolved_target = b.resolveTargetQuery(target_query); - const target = resolved_target.result; + const target = &resolved_target.result; for (backends) |backend| { if (backend == .stage2 and target.cpu.arch != .wasm32 and target.cpu.arch != .x86_64 and target.cpu.arch != .spirv64) @@ -708,7 +708,7 @@ pub fn lowerToBuildSteps( }, .Execution => |expected_stdout| no_exec: { const run = if (case.target.result.ofmt == .c) run_step: { - if (getExternalExecutor(host, &case.target.result, .{ .link_libc = true }) != .native) { + if (getExternalExecutor(&host, &case.target.result, .{ .link_libc = true }) != .native) { // We wouldn't be able to run the compiled C code. break :no_exec; } diff --git a/test/src/Debugger.zig b/test/src/Debugger.zig index 6ed888df1d2d..dea3ee91cef4 100644 --- a/test/src/Debugger.zig +++ b/test/src/Debugger.zig @@ -21,7 +21,7 @@ pub const Target = struct { test_name_suffix: []const u8, }; -pub fn addTestsForTarget(db: *Debugger, target: Target) void { +pub fn addTestsForTarget(db: *Debugger, target: *const Target) void { db.addLldbTest( "basic", target, @@ -2376,7 +2376,7 @@ const File = struct { import: ?[]const u8 = null, path: []const u8, source: []co fn addGdbTest( db: *Debugger, name: []const u8, - target: Target, + target: *const Target, files: []const File, commands: []const u8, expected_output: []const []const u8, @@ -2402,7 +2402,7 @@ fn addGdbTest( fn addLldbTest( db: *Debugger, name: []const u8, - target: Target, + target: *const Target, files: []const File, commands: []const u8, expected_output: []const []const u8, @@ -2433,7 +2433,7 @@ const success = 99; fn addTest( db: *Debugger, name: []const u8, - target: Target, + target: *const Target, files: []const File, db_argv1: []const []const u8, db_commands: []const u8, diff --git a/test/src/StackTrace.zig b/test/src/StackTrace.zig index 2ca5869eaf1e..d956e27cd7eb 100644 --- a/test/src/StackTrace.zig +++ b/test/src/StackTrace.zig @@ -22,7 +22,7 @@ const Config = struct { pub fn addCase(self: *StackTrace, config: Config) void { self.addCaseInner(config, true); - if (shouldTestNonLlvm(self.b.graph.host.result)) { + if (shouldTestNonLlvm(&self.b.graph.host.result)) { self.addCaseInner(config, false); } } @@ -41,7 +41,7 @@ fn addCaseInner(self: *StackTrace, config: Config, use_llvm: bool) void { self.addExpect(config.name, config.source, .ReleaseSafe, use_llvm, per_mode); } -fn shouldTestNonLlvm(target: std.Target) bool { +fn shouldTestNonLlvm(target: *const std.Target) bool { return switch (target.cpu.arch) { .x86_64 => switch (target.ofmt) { .elf => true, diff --git a/test/standalone/ios/build.zig b/test/standalone/ios/build.zig index 6148920b54ba..0695f48f3f8d 100644 --- a/test/standalone/ios/build.zig +++ b/test/standalone/ios/build.zig @@ -12,7 +12,7 @@ pub fn build(b: *std.Build) void { .cpu_arch = .aarch64, .os_tag = .ios, }); - const sdk = std.zig.system.darwin.getSdk(b.allocator, target.result) orelse + const sdk = std.zig.system.darwin.getSdk(b.allocator, &target.result) orelse @panic("no iOS SDK found"); b.sysroot = sdk; diff --git a/test/tests.zig b/test/tests.zig index 500deb84097d..c7ed0e59b5b7 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -2311,7 +2311,7 @@ pub fn addModuleTests(b: *std.Build, options: ModuleTestOptions) *Step { const resolved_target = b.resolveTargetQuery(test_target.target); const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); - const target = resolved_target.result; + const target = &resolved_target.result; if (options.test_target_filters.len > 0) { for (options.test_target_filters) |filter| { @@ -2557,7 +2557,7 @@ pub fn addCAbiTests(b: *std.Build, options: CAbiTestOptions) *Step { const resolved_target = b.resolveTargetQuery(c_abi_target.target); const triple_txt = resolved_target.query.zigTriple(b.allocator) catch @panic("OOM"); - const target = resolved_target.result; + const target = &resolved_target.result; if (options.test_target_filters.len > 0) { for (options.test_target_filters) |filter| { @@ -2659,7 +2659,7 @@ pub fn addDebuggerTests(b: *std.Build, options: DebuggerContext.Options) ?*Step .options = options, .root_step = step, }; - context.addTestsForTarget(.{ + context.addTestsForTarget(&.{ .resolved = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .linux, @@ -2668,7 +2668,7 @@ pub fn addDebuggerTests(b: *std.Build, options: DebuggerContext.Options) ?*Step .pic = false, .test_name_suffix = "x86_64-linux", }); - context.addTestsForTarget(.{ + context.addTestsForTarget(&.{ .resolved = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .linux, diff --git a/tools/doctest.zig b/tools/doctest.zig index 86eb2009bde7..af5ce9f983aa 100644 --- a/tools/doctest.zig +++ b/tools/doctest.zig @@ -317,7 +317,7 @@ fn printOutput( const target = try std.zig.system.resolveTargetQuery( target_query, ); - switch (getExternalExecutor(host, &target, .{ + switch (getExternalExecutor(&host, &target, .{ .link_libc = code.link_libc, })) { .native => {}, @@ -538,7 +538,7 @@ fn printOutput( .lib => { const bin_basename = try std.zig.binNameAlloc(arena, .{ .root_name = code_name, - .target = builtin.target, + .target = &builtin.target, .output_mode = .Lib, }); diff --git a/tools/incr-check.zig b/tools/incr-check.zig index 6c048f7a8709..08b8a21e3b2e 100644 --- a/tools/incr-check.zig +++ b/tools/incr-check.zig @@ -316,7 +316,7 @@ const Eval = struct { const bin_name = try std.zig.EmitArtifact.bin.cacheName(arena, .{ .root_name = "root", // corresponds to the module name "root" - .target = eval.target.resolved, + .target = &eval.target.resolved, .output_mode = .Exe, }); const bin_path = try std.fs.path.join(arena, &.{ result_dir, bin_name }); @@ -444,7 +444,7 @@ const Eval = struct { var argv_buf: [2][]const u8 = undefined; const argv: []const []const u8, const is_foreign: bool = switch (std.zig.system.getExternalExecutor( - eval.host, + &eval.host, &eval.target.resolved, .{ .link_libc = eval.target.backend == .cbe }, )) { From e92b12906338207975ee73aa99db63cb9240bf04 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Thu, 19 Jun 2025 17:54:25 -0400 Subject: [PATCH 4/6] Compilation: fix use after free Closes #23967 --- src/Compilation.zig | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/src/Compilation.zig b/src/Compilation.zig index 402a3f9761b4..e0f8cf5a56d2 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1990,9 +1990,6 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil }; errdefer if (opt_zcu) |zcu| zcu.deinit(); - var windows_libs = try std.StringArrayHashMapUnmanaged(void).init(gpa, options.windows_lib_names, &.{}); - errdefer windows_libs.deinit(gpa); - comp.* = .{ .gpa = gpa, .arena = arena, @@ -2037,7 +2034,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil .incremental = options.incremental, .root_name = root_name, .sysroot = sysroot, - .windows_libs = windows_libs, + .windows_libs = .empty, .version = options.version, .libc_installation = libc_dirs.libc_installation, .compiler_rt_strat = compiler_rt_strat, @@ -2065,6 +2062,13 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil .emit_docs = try options.emit_docs.resolve(arena, &options, .docs), }; + errdefer { + for (comp.windows_libs.keys()) |windows_lib| gpa.free(windows_lib); + comp.windows_libs.deinit(gpa); + } + try comp.windows_libs.ensureUnusedCapacity(gpa, options.windows_lib_names.len); + for (options.windows_lib_names) |windows_lib| comp.windows_libs.putAssumeCapacity(try gpa.dupe(u8, windows_lib), {}); + // Prevent some footguns by making the "any" fields of config reflect // the default Module settings. comp.config.any_unwind_tables = any_unwind_tables; @@ -2387,7 +2391,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil // When linking mingw-w64 there are some import libs we always need. try comp.windows_libs.ensureUnusedCapacity(gpa, mingw.always_link_libs.len); - for (mingw.always_link_libs) |name| comp.windows_libs.putAssumeCapacity(name, {}); + for (mingw.always_link_libs) |name| comp.windows_libs.putAssumeCapacity(try gpa.dupe(u8, name), {}); } else { return error.LibCUnavailable; } @@ -2480,6 +2484,7 @@ pub fn destroy(comp: *Compilation) void { comp.c_object_work_queue.deinit(); comp.win32_resource_work_queue.deinit(); + for (comp.windows_libs.keys()) |windows_lib| gpa.free(windows_lib); comp.windows_libs.deinit(gpa); { @@ -7563,7 +7568,12 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void { // If we haven't seen this library yet and we're targeting Windows, we need // to queue up a work item to produce the DLL import library for this. const gop = try comp.windows_libs.getOrPut(comp.gpa, lib_name); - if (!gop.found_existing) try comp.queueJob(.{ .windows_import_lib = comp.windows_libs.count() - 1 }); + if (gop.found_existing) return; + { + errdefer _ = comp.windows_libs.pop(); + gop.key_ptr.* = try comp.gpa.dupe(u8, lib_name); + } + try comp.queueJob(.{ .windows_import_lib = gop.index }); } /// This decides the optimization mode for all zig-provided libraries, including From ed37a1a33c2576c00697643463a4720728e04023 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Mon, 9 Jun 2025 18:38:39 -0400 Subject: [PATCH 5/6] coff: add hack to build a compiler-rt dynamic library This is not meant to be a long-term solution, but it's the easiest thing to get working quickly at the moment. The main intention of this hack is to allow more tests to be enabled. By the time the coff linker is far enough along to be enabled by default, this will no longer be required. --- lib/compiler_rt/common.zig | 6 ++--- src/Compilation.zig | 46 +++++++++++++++++++++++++++++++++++--- src/link/Coff.zig | 15 +++++++++++++ 3 files changed, 61 insertions(+), 6 deletions(-) diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index 747e74841e49..978e701130ec 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -16,10 +16,10 @@ else /// Determines the symbol's visibility to other objects. /// For WebAssembly this allows the symbol to be resolved to other modules, but will not /// export it to the host runtime. -pub const visibility: std.builtin.SymbolVisibility = if (linkage != .internal) - .hidden +pub const visibility: std.builtin.SymbolVisibility = if (linkage == .internal or builtin.link_mode == .dynamic) + .default else - .default; + .hidden; pub const PreferredLoadStoreElement = element: { if (std.simd.suggestVectorLength(u8)) |vec_size| { diff --git a/src/Compilation.zig b/src/Compilation.zig index e0f8cf5a56d2..4136b21f6137 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -224,6 +224,8 @@ compiler_rt_lib: ?CrtFile = null, /// Populated when we build the compiler_rt_obj object. A Job to build this is indicated /// by setting `queued_jobs.compiler_rt_obj` and resolved before calling linker.flush(). compiler_rt_obj: ?CrtFile = null, +/// hack for stage2_x86_64 + coff +compiler_rt_dyn_lib: ?CrtFile = null, /// Populated when we build the libfuzzer static library. A Job to build this /// is indicated by setting `queued_jobs.fuzzer_lib` and resolved before /// calling linker.flush(). @@ -291,6 +293,8 @@ emit_llvm_bc: ?[]const u8, emit_docs: ?[]const u8, const QueuedJobs = struct { + /// hack for stage2_x86_64 + coff + compiler_rt_dyn_lib: bool = false, compiler_rt_lib: bool = false, compiler_rt_obj: bool = false, ubsan_rt_lib: bool = false, @@ -1753,7 +1757,7 @@ fn addModuleTableToCacheHash( } } -const RtStrat = enum { none, lib, obj, zcu }; +const RtStrat = enum { none, lib, obj, zcu, dyn_lib }; pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compilation { const output_mode = options.config.output_mode; @@ -1816,7 +1820,11 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil if (options.skip_linker_dependencies) break :s .none; const want = options.want_compiler_rt orelse is_exe_or_dyn_lib; if (!want) break :s .none; - if (have_zcu and output_mode == .Obj) break :s .zcu; + if (have_zcu) { + if (output_mode == .Obj) break :s .zcu; + if (target.ofmt == .coff and target_util.zigBackend(target, use_llvm) == .stage2_x86_64) + break :s if (is_exe_or_dyn_lib) .dyn_lib else .zcu; + } if (is_exe_or_dyn_lib) break :s .lib; break :s .obj; }; @@ -2441,6 +2449,11 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil // for a compiler-rt object to put in it. comp.queued_jobs.compiler_rt_obj = true; comp.link_task_queue.pending_prelink_tasks += 1; + } else if (comp.compiler_rt_strat == .dyn_lib) { + // hack for stage2_x86_64 + coff + log.debug("queuing a job to build compiler_rt_dyn_lib", .{}); + comp.queued_jobs.compiler_rt_dyn_lib = true; + comp.link_task_queue.pending_prelink_tasks += 1; } if (comp.ubsan_rt_strat == .lib) { @@ -4254,6 +4267,7 @@ fn performAllTheWork( "compiler_rt.zig", "compiler_rt", .Lib, + .static, .compiler_rt, main_progress_node, RtOptions{ @@ -4270,6 +4284,7 @@ fn performAllTheWork( "compiler_rt.zig", "compiler_rt", .Obj, + .static, .compiler_rt, main_progress_node, RtOptions{ @@ -4280,12 +4295,31 @@ fn performAllTheWork( }); } + // hack for stage2_x86_64 + coff + if (comp.queued_jobs.compiler_rt_dyn_lib and comp.compiler_rt_dyn_lib == null) { + comp.link_task_wait_group.spawnManager(buildRt, .{ + comp, + "compiler_rt.zig", + "compiler_rt", + .Lib, + .dynamic, + .compiler_rt, + main_progress_node, + RtOptions{ + .checks_valgrind = true, + .allow_lto = false, + }, + &comp.compiler_rt_dyn_lib, + }); + } + if (comp.queued_jobs.fuzzer_lib and comp.fuzzer_lib == null) { comp.link_task_wait_group.spawnManager(buildRt, .{ comp, "fuzzer.zig", "fuzzer", .Lib, + .static, .libfuzzer, main_progress_node, RtOptions{}, @@ -4299,6 +4333,7 @@ fn performAllTheWork( "ubsan_rt.zig", "ubsan_rt", .Lib, + .static, .libubsan, main_progress_node, RtOptions{ @@ -4314,6 +4349,7 @@ fn performAllTheWork( "ubsan_rt.zig", "ubsan_rt", .Obj, + .static, .libubsan, main_progress_node, RtOptions{ @@ -5390,6 +5426,7 @@ fn buildRt( root_source_name: []const u8, root_name: []const u8, output_mode: std.builtin.OutputMode, + link_mode: std.builtin.LinkMode, misc_task: MiscTask, prog_node: std.Progress.Node, options: RtOptions, @@ -5399,6 +5436,7 @@ fn buildRt( root_source_name, root_name, output_mode, + link_mode, misc_task, prog_node, options, @@ -5554,6 +5592,7 @@ fn buildLibZigC(comp: *Compilation, prog_node: std.Progress.Node) void { "c.zig", "zigc", .Lib, + .static, .libzigc, prog_node, .{}, @@ -7231,6 +7270,7 @@ fn buildOutputFromZig( src_basename: []const u8, root_name: []const u8, output_mode: std.builtin.OutputMode, + link_mode: std.builtin.LinkMode, misc_task_tag: MiscTask, prog_node: std.Progress.Node, options: RtOptions, @@ -7251,7 +7291,7 @@ fn buildOutputFromZig( const config = try Config.resolve(.{ .output_mode = output_mode, - .link_mode = .static, + .link_mode = link_mode, .resolved_target = comp.root_mod.resolved_target, .is_test = false, .have_zcu = true, diff --git a/src/link/Coff.zig b/src/link/Coff.zig index d774f14bf634..2ca7ec6de0fd 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -1715,6 +1715,21 @@ fn flushInner(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id) !void { } assert(!coff.imports_count_dirty); + + // hack for stage2_x86_64 + coff + if (comp.compiler_rt_dyn_lib) |crt_file| { + const compiler_rt_sub_path = try std.fs.path.join(gpa, &.{ + std.fs.path.dirname(coff.base.emit.sub_path) orelse "", + std.fs.path.basename(crt_file.full_object_path.sub_path), + }); + defer gpa.free(compiler_rt_sub_path); + try crt_file.full_object_path.root_dir.handle.copyFile( + crt_file.full_object_path.sub_path, + coff.base.emit.root_dir.handle, + compiler_rt_sub_path, + .{}, + ); + } } pub fn getNavVAddr( From 1f98c98fffb09bf15a9fc04ecd5f1fa38a4bd4b8 Mon Sep 17 00:00:00 2001 From: Jacob Young Date: Fri, 13 Jun 2025 04:41:21 -0400 Subject: [PATCH 6/6] x86_64: increase passing test coverage on windows Now that codegen has no references to linker state this is much easier. Closes #24153 --- lib/compiler_rt/stack_probe.zig | 56 +- lib/std/math/float.zig | 63 +- lib/std/math/signbit.zig | 53 +- lib/std/posix.zig | 5 +- lib/std/start.zig | 6 + src/Air/Legalize.zig | 16 +- src/arch/riscv64/CodeGen.zig | 19 +- src/arch/x86_64/CodeGen.zig | 18865 ++++++++++------ src/arch/x86_64/Emit.zig | 16 +- src/arch/x86_64/Encoding.zig | 4 +- src/arch/x86_64/Mir.zig | 3 + src/arch/x86_64/abi.zig | 296 +- src/arch/x86_64/bits.zig | 32 +- src/codegen.zig | 107 +- src/codegen/llvm.zig | 22 +- src/link.zig | 2 +- src/link/Coff.zig | 58 +- src/link/Elf.zig | 2 +- src/link/Elf/ZigObject.zig | 26 +- src/link/MachO.zig | 2 +- src/link/MachO/ZigObject.zig | 28 +- src/link/Plan9.zig | 6 +- test/behavior/abs.zig | 2 - test/behavior/basic.zig | 15 +- test/behavior/bit_shifting.zig | 1 - test/behavior/bitcast.zig | 3 - test/behavior/cast.zig | 11 +- test/behavior/eval.zig | 1 - test/behavior/export_keyword.zig | 2 +- test/behavior/floatop.zig | 103 +- test/behavior/generics.zig | 1 - test/behavior/math.zig | 24 +- test/behavior/maximum_minimum.zig | 1 - test/behavior/memmove.zig | 4 - test/behavior/muladd.zig | 15 - ...ultiple_externs_with_conflicting_types.zig | 2 +- test/behavior/optional.zig | 1 - test/behavior/packed-struct.zig | 1 - test/behavior/saturating_arithmetic.zig | 7 - test/behavior/struct.zig | 1 - test/behavior/tuple.zig | 1 - test/behavior/union.zig | 2 - test/behavior/vector.zig | 15 - test/behavior/widening.zig | 2 - test/behavior/x86_64.zig | 2 - test/behavior/x86_64/binary.zig | 156 +- test/behavior/x86_64/build.zig | 45 + test/behavior/x86_64/cast.zig | 21 +- test/behavior/x86_64/math.zig | 86 +- test/behavior/x86_64/unary.zig | 101 +- test/tests.zig | 9 + 51 files changed, 12364 insertions(+), 7958 deletions(-) diff --git a/lib/compiler_rt/stack_probe.zig b/lib/compiler_rt/stack_probe.zig index c45946900a22..afc124196f9e 100644 --- a/lib/compiler_rt/stack_probe.zig +++ b/lib/compiler_rt/stack_probe.zig @@ -127,23 +127,23 @@ fn win_probe_stack_only() void { }, .x86_64 => { asm volatile ( - \\ push %%rcx - \\ push %%rax - \\ cmp $0x1000,%%rax - \\ lea 24(%%rsp),%%rcx + \\ pushq %%rcx + \\ pushq %%rax + \\ cmpq $0x1000,%%rax + \\ leaq 24(%%rsp),%%rcx \\ jb 1f \\ 2: - \\ sub $0x1000,%%rcx - \\ test %%rcx,(%%rcx) - \\ sub $0x1000,%%rax - \\ cmp $0x1000,%%rax + \\ subq $0x1000,%%rcx + \\ testq %%rcx,(%%rcx) + \\ subq $0x1000,%%rax + \\ cmpq $0x1000,%%rax \\ ja 2b \\ 1: - \\ sub %%rax,%%rcx - \\ test %%rcx,(%%rcx) - \\ pop %%rax - \\ pop %%rcx - \\ ret + \\ subq %%rax,%%rcx + \\ testq %%rcx,(%%rcx) + \\ popq %%rax + \\ popq %%rcx + \\ retq ); }, .x86 => { @@ -179,26 +179,26 @@ fn win_probe_stack_adjust_sp() void { switch (arch) { .x86_64 => { asm volatile ( - \\ push %%rcx - \\ cmp $0x1000,%%rax - \\ lea 16(%%rsp),%%rcx + \\ pushq %%rcx + \\ cmpq $0x1000,%%rax + \\ leaq 16(%%rsp),%%rcx \\ jb 1f \\ 2: - \\ sub $0x1000,%%rcx - \\ test %%rcx,(%%rcx) - \\ sub $0x1000,%%rax - \\ cmp $0x1000,%%rax + \\ subq $0x1000,%%rcx + \\ testq %%rcx,(%%rcx) + \\ subq $0x1000,%%rax + \\ cmpq $0x1000,%%rax \\ ja 2b \\ 1: - \\ sub %%rax,%%rcx - \\ test %%rcx,(%%rcx) + \\ subq %%rax,%%rcx + \\ testq %%rcx,(%%rcx) \\ - \\ lea 8(%%rsp),%%rax - \\ mov %%rcx,%%rsp - \\ mov -8(%%rax),%%rcx - \\ push (%%rax) - \\ sub %%rsp,%%rax - \\ ret + \\ leaq 8(%%rsp),%%rax + \\ movq %%rcx,%%rsp + \\ movq -8(%%rax),%%rcx + \\ pushq (%%rax) + \\ subq %%rsp,%%rax + \\ retq ); }, .x86 => { diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig index d545d6390aca..df7d7fe1abcf 100644 --- a/lib/std/math/float.zig +++ b/lib/std/math/float.zig @@ -220,42 +220,61 @@ pub inline fn floatEpsAt(comptime T: type, x: T) T { } } -/// Returns the value inf for floating point type T. -pub inline fn inf(comptime T: type) T { - return reconstructFloat(T, floatExponentMax(T) + 1, mantissaOne(T)); +/// Returns the inf value for a floating point `Type`. +pub inline fn inf(comptime Type: type) Type { + const RuntimeType = switch (Type) { + else => Type, + comptime_float => f128, // any float type will do + }; + return reconstructFloat(RuntimeType, floatExponentMax(RuntimeType) + 1, mantissaOne(RuntimeType)); } -/// Returns the canonical quiet NaN representation for floating point type T. -pub inline fn nan(comptime T: type) T { +/// Returns the canonical quiet NaN representation for a floating point `Type`. +pub inline fn nan(comptime Type: type) Type { + const RuntimeType = switch (Type) { + else => Type, + comptime_float => f128, // any float type will do + }; return reconstructFloat( - T, - floatExponentMax(T) + 1, - mantissaOne(T) | 1 << (floatFractionalBits(T) - 1), + RuntimeType, + floatExponentMax(RuntimeType) + 1, + mantissaOne(RuntimeType) | 1 << (floatFractionalBits(RuntimeType) - 1), ); } -/// Returns a signalling NaN representation for floating point type T. +/// Returns a signalling NaN representation for a floating point `Type`. /// /// TODO: LLVM is known to miscompile on some architectures to quiet NaN - /// this is tracked by https://github.com/ziglang/zig/issues/14366 -pub inline fn snan(comptime T: type) T { +pub inline fn snan(comptime Type: type) Type { + const RuntimeType = switch (Type) { + else => Type, + comptime_float => f128, // any float type will do + }; return reconstructFloat( - T, - floatExponentMax(T) + 1, - mantissaOne(T) | 1 << (floatFractionalBits(T) - 2), + RuntimeType, + floatExponentMax(RuntimeType) + 1, + mantissaOne(RuntimeType) | 1 << (floatFractionalBits(RuntimeType) - 2), ); } -test "float bits" { - inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) |T| { - // (1 +) for the sign bit, since it is separate from the other bits - const size = 1 + floatExponentBits(T) + floatMantissaBits(T); - try expect(@bitSizeOf(T) == size); +fn floatBits(comptime Type: type) !void { + // (1 +) for the sign bit, since it is separate from the other bits + const size = 1 + floatExponentBits(Type) + floatMantissaBits(Type); + try expect(@bitSizeOf(Type) == size); + try expect(floatFractionalBits(Type) <= floatMantissaBits(Type)); - // for machine epsilon, assert expmin <= -prec <= expmax - try expect(floatExponentMin(T) <= -floatFractionalBits(T)); - try expect(-floatFractionalBits(T) <= floatExponentMax(T)); - } + // for machine epsilon, assert expmin <= -prec <= expmax + try expect(floatExponentMin(Type) <= -floatFractionalBits(Type)); + try expect(-floatFractionalBits(Type) <= floatExponentMax(Type)); +} +test floatBits { + try floatBits(f16); + try floatBits(f32); + try floatBits(f64); + try floatBits(f80); + try floatBits(f128); + try floatBits(c_longdouble); } test inf { diff --git a/lib/std/math/signbit.zig b/lib/std/math/signbit.zig index 97dd03613aed..2b50d0cbd9ff 100644 --- a/lib/std/math/signbit.zig +++ b/lib/std/math/signbit.zig @@ -4,20 +4,47 @@ const expect = std.testing.expect; /// Returns whether x is negative or negative 0. pub fn signbit(x: anytype) bool { - const T = @TypeOf(x); - const TBits = std.meta.Int(.unsigned, @typeInfo(T).float.bits); - return @as(TBits, @bitCast(x)) >> (@bitSizeOf(T) - 1) != 0; + return switch (@typeInfo(@TypeOf(x))) { + .int, .comptime_int => x, + .float => |float| @as(@Type(.{ .int = .{ + .signedness = .signed, + .bits = float.bits, + } }), @bitCast(x)), + .comptime_float => @as(i128, @bitCast(@as(f128, x))), // any float type will do + else => @compileError("std.math.signbit does not support " ++ @typeName(@TypeOf(x))), + } < 0; } test signbit { - inline for ([_]type{ f16, f32, f64, f80, f128 }) |T| { - try expect(!signbit(@as(T, 0.0))); - try expect(!signbit(@as(T, 1.0))); - try expect(signbit(@as(T, -2.0))); - try expect(signbit(@as(T, -0.0))); - try expect(!signbit(math.inf(T))); - try expect(signbit(-math.inf(T))); - try expect(!signbit(math.nan(T))); - try expect(signbit(-math.nan(T))); - } + try testInts(i0); + try testInts(u0); + try testInts(i1); + try testInts(u1); + try testInts(i2); + try testInts(u2); + + try testFloats(f16); + try testFloats(f32); + try testFloats(f64); + try testFloats(f80); + try testFloats(f128); + try testFloats(c_longdouble); + try testFloats(comptime_float); +} + +fn testInts(comptime Type: type) !void { + try expect((std.math.minInt(Type) < 0) == signbit(@as(Type, std.math.minInt(Type)))); + try expect(!signbit(@as(Type, 0))); + try expect(!signbit(@as(Type, std.math.maxInt(Type)))); +} + +fn testFloats(comptime Type: type) !void { + try expect(!signbit(@as(Type, 0.0))); + try expect(!signbit(@as(Type, 1.0))); + try expect(signbit(@as(Type, -2.0))); + try expect(signbit(@as(Type, -0.0))); + try expect(!signbit(math.inf(Type))); + try expect(signbit(-math.inf(Type))); + try expect(!signbit(math.nan(Type))); + try expect(signbit(-math.nan(Type))); } diff --git a/lib/std/posix.zig b/lib/std/posix.zig index 936c19591a88..7a517b9a477c 100644 --- a/lib/std/posix.zig +++ b/lib/std/posix.zig @@ -7571,7 +7571,10 @@ const lfs64_abi = native_os == .linux and builtin.link_libc and (builtin.abi.isG /// If this happens the fix is to add the error code to the corresponding /// switch expression, possibly introduce a new error in the error set, and /// send a patch to Zig. -pub const unexpected_error_tracing = builtin.zig_backend == .stage2_llvm and builtin.mode == .Debug; +pub const unexpected_error_tracing = builtin.mode == .Debug and switch (builtin.zig_backend) { + .stage2_llvm, .stage2_x86_64 => true, + else => false, +}; pub const UnexpectedError = error{ /// The Operating System returned an undocumented error code. diff --git a/lib/std/start.zig b/lib/std/start.zig index 364844e54d62..a74b83fe8194 100644 --- a/lib/std/start.zig +++ b/lib/std/start.zig @@ -485,6 +485,9 @@ fn _start() callconv(.naked) noreturn { } fn WinStartup() callconv(.withStackAlign(.c, 1)) noreturn { + // Switch from the x87 fpu state set by windows to the state expected by the gnu abi. + if (builtin.abi == .gnu) asm volatile ("fninit"); + if (!builtin.single_threaded and !builtin.link_libc) { _ = @import("os/windows/tls.zig"); } @@ -495,6 +498,9 @@ fn WinStartup() callconv(.withStackAlign(.c, 1)) noreturn { } fn wWinMainCRTStartup() callconv(.withStackAlign(.c, 1)) noreturn { + // Switch from the x87 fpu state set by windows to the state expected by the gnu abi. + if (builtin.abi == .gnu) asm volatile ("fninit"); + if (!builtin.single_threaded and !builtin.link_libc) { _ = @import("os/windows/tls.zig"); } diff --git a/src/Air/Legalize.zig b/src/Air/Legalize.zig index dafb3e5ed789..5cd90bba0146 100644 --- a/src/Air/Legalize.zig +++ b/src/Air/Legalize.zig @@ -122,8 +122,10 @@ pub const Feature = enum { /// Legalize (shift lhs, (splat rhs)) -> (shift lhs, rhs) unsplat_shift_rhs, - /// Legalize reduce of a one element vector to a bitcast + /// Legalize reduce of a one element vector to a bitcast. reduce_one_elem_to_bitcast, + /// Legalize splat to a one element vector to a bitcast. + splat_one_elem_to_bitcast, /// Replace `intcast_safe` with an explicit safety check which `call`s the panic function on failure. /// Not compatible with `scalarize_intcast_safe`. @@ -628,7 +630,17 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { else => {}, } }, - .splat => {}, + .splat => if (l.features.has(.splat_one_elem_to_bitcast)) { + const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + switch (ty_op.ty.toType().vectorLen(zcu)) { + 0 => unreachable, + 1 => continue :inst l.replaceInst(inst, .bitcast, .{ .ty_op = .{ + .ty = ty_op.ty, + .operand = ty_op.operand, + } }), + else => {}, + } + }, .shuffle_one => if (l.features.has(.scalarize_shuffle_one)) continue :inst try l.scalarize(inst, .shuffle_one), .shuffle_two => if (l.features.has(.scalarize_shuffle_two)) continue :inst try l.scalarize(inst, .shuffle_two), .select => if (l.features.has(.scalarize_select)) continue :inst try l.scalarize(inst, .select), diff --git a/src/arch/riscv64/CodeGen.zig b/src/arch/riscv64/CodeGen.zig index fcaa46666df9..b9a16d5a75f8 100644 --- a/src/arch/riscv64/CodeGen.zig +++ b/src/arch/riscv64/CodeGen.zig @@ -5962,10 +5962,14 @@ fn airBr(func: *Func, inst: Air.Inst.Index) !void { if (first_br) break :result src_mcv; try func.getValue(block_tracking.short, br.block_inst); - // .long = .none to avoid merging operand and block result stack frames. - const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv }; - try current_tracking.materializeUnsafe(func, br.block_inst, block_tracking.*); - for (current_tracking.getRegs()) |src_reg| func.register_manager.freeReg(src_reg); + try InstTracking.materializeUnsafe( + // .long = .none to avoid merging operand and block result stack frames. + .{ .long = .none, .short = src_mcv }, + func, + br.block_inst, + block_tracking.*, + ); + try func.freeValue(src_mcv); break :result block_tracking.short; } @@ -8192,8 +8196,11 @@ fn genTypedValue(func: *Func, val: Value) InnerError!MCValue { const lf = func.bin_file; const src_loc = func.src_loc; - const result = if (val.isUndef(pt.zcu)) - try lf.lowerUav(pt, val.toIntern(), .none, src_loc) + const result: codegen.GenResult = if (val.isUndef(pt.zcu)) + switch (try lf.lowerUav(pt, val.toIntern(), .none, src_loc)) { + .sym_index => |sym_index| .{ .mcv = .{ .load_symbol = sym_index } }, + .fail => |em| .{ .fail = em }, + } else try codegen.genTypedValue(lf, pt, src_loc, val, func.target); const mcv: MCValue = switch (result) { diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 663154d8843a..6a6022b62d27 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -32,88 +32,47 @@ const FrameIndex = bits.FrameIndex; const InnerError = codegen.CodeGenError || error{OutOfRegisters}; -pub fn legalizeFeatures(target: *const std.Target) *const Air.Legalize.Features { - @setEvalBranchQuota(1_200); - return switch (target.ofmt == .coff) { - inline false, true => |use_old| comptime &.init(.{ - .scalarize_add = use_old, - .scalarize_add_sat = use_old, - .scalarize_sub = use_old, - .scalarize_sub_sat = use_old, - .scalarize_mul = use_old, - .scalarize_mul_wrap = use_old, - .scalarize_mul_sat = true, - .scalarize_div_float = use_old, - .scalarize_div_float_optimized = use_old, - .scalarize_div_trunc = use_old, - .scalarize_div_trunc_optimized = use_old, - .scalarize_div_floor = true, - .scalarize_div_floor_optimized = use_old, - .scalarize_div_exact = use_old, - .scalarize_div_exact_optimized = use_old, - .scalarize_mod = true, - .scalarize_max = use_old, - .scalarize_min = use_old, - .scalarize_add_with_overflow = true, - .scalarize_sub_with_overflow = true, - .scalarize_mul_with_overflow = true, - .scalarize_shl_with_overflow = true, - .scalarize_bit_and = use_old, - .scalarize_bit_or = use_old, - .scalarize_shr = true, - .scalarize_shr_exact = true, - .scalarize_shl = true, - .scalarize_shl_exact = true, - .scalarize_shl_sat = true, - .scalarize_xor = use_old, - .scalarize_not = use_old, - .scalarize_bitcast = true, - .scalarize_clz = use_old, - .scalarize_ctz = true, - .scalarize_popcount = true, - .scalarize_byte_swap = true, - .scalarize_bit_reverse = true, - .scalarize_sin = use_old, - .scalarize_cos = use_old, - .scalarize_tan = use_old, - .scalarize_exp = use_old, - .scalarize_exp2 = use_old, - .scalarize_log = use_old, - .scalarize_log2 = use_old, - .scalarize_log10 = use_old, - .scalarize_abs = use_old, - .scalarize_floor = use_old, - .scalarize_ceil = use_old, - .scalarize_trunc_float = use_old, - .scalarize_cmp_vector = true, - .scalarize_cmp_vector_optimized = true, - .scalarize_fptrunc = use_old, - .scalarize_fpext = use_old, - .scalarize_intcast = use_old, - .scalarize_int_from_float = use_old, - .scalarize_int_from_float_optimized = use_old, - .scalarize_float_from_int = use_old, - .scalarize_shuffle_one = true, - .scalarize_shuffle_two = true, - .scalarize_select = true, - .scalarize_mul_add = use_old, - - .unsplat_shift_rhs = false, - .reduce_one_elem_to_bitcast = true, - - .expand_intcast_safe = true, - .expand_int_from_float_safe = true, - .expand_int_from_float_optimized_safe = true, - .expand_add_safe = true, - .expand_sub_safe = true, - .expand_mul_safe = true, - - .expand_packed_load = true, - .expand_packed_store = true, - .expand_packed_struct_field_val = true, - .expand_packed_aggregate_init = true, - }), - }; +pub fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { + return comptime &.initMany(&.{ + .scalarize_mul_sat, + .scalarize_div_floor, + .scalarize_mod, + .scalarize_add_with_overflow, + .scalarize_sub_with_overflow, + .scalarize_mul_with_overflow, + .scalarize_shl_with_overflow, + .scalarize_shr, + .scalarize_shr_exact, + .scalarize_shl, + .scalarize_shl_exact, + .scalarize_shl_sat, + .scalarize_bitcast, + .scalarize_ctz, + .scalarize_popcount, + .scalarize_byte_swap, + .scalarize_bit_reverse, + .scalarize_cmp_vector, + .scalarize_cmp_vector_optimized, + .scalarize_shuffle_one, + .scalarize_shuffle_two, + .scalarize_select, + + //.unsplat_shift_rhs, + .reduce_one_elem_to_bitcast, + .splat_one_elem_to_bitcast, + + .expand_intcast_safe, + .expand_int_from_float_safe, + .expand_int_from_float_optimized_safe, + .expand_add_safe, + .expand_sub_safe, + .expand_mul_safe, + + .expand_packed_load, + .expand_packed_store, + .expand_packed_struct_field_val, + .expand_packed_aggregate_init, + }); } /// Set this to `false` to uncover Sema OPV bugs. @@ -246,6 +205,7 @@ pub const MCValue = union(enum) { 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 stored at an offset from a frame index /// Payload is a frame address. load_frame: bits.FrameAddr, @@ -279,6 +239,7 @@ pub const MCValue = union(enum) { .register_mask, .eflags, .register_overflow, + .indirect_load_frame, .lea_frame, .lea_nav, .load_uav, @@ -417,6 +378,7 @@ pub const MCValue = union(enum) { 0 => .{ .register = reg_off.reg }, else => .{ .register_offset = reg_off }, }, + .indirect_load_frame => |frame_addr| .{ .load_frame = frame_addr }, .load_frame => |frame_addr| .{ .lea_frame = frame_addr }, .load_nav => |nav| .{ .lea_nav = nav }, .load_uav => |uav| .{ .lea_uav = uav }, @@ -439,7 +401,7 @@ pub const MCValue = union(enum) { .register_mask, .memory, .indirect, - .load_frame, + .indirect_load_frame, .load_nav, .load_uav, .load_lazy_sym, @@ -451,6 +413,7 @@ pub const MCValue = union(enum) { .immediate => |addr| .{ .memory = addr }, .register => |reg| .{ .indirect = .{ .reg = reg } }, .register_offset => |reg_off| .{ .indirect = reg_off }, + .load_frame => |frame_addr| .{ .indirect_load_frame = frame_addr }, .lea_frame => |frame_addr| .{ .load_frame = frame_addr }, .lea_nav => |nav| .{ .load_nav = nav }, .lea_uav => |uav| .{ .load_uav = uav }, @@ -477,6 +440,7 @@ pub const MCValue = union(enum) { .register_mask, .memory, .indirect, + .indirect_load_frame, .load_frame, .load_nav, .lea_nav, @@ -516,6 +480,7 @@ pub const MCValue = union(enum) { .register_offset, .register_overflow, .register_mask, + .indirect_load_frame, .lea_frame, .elementwise_args, .reserved_frame, @@ -589,6 +554,7 @@ pub const MCValue = union(enum) { @tagName(pl.reg), }), .indirect => |pl| try writer.print("[{s} + 0x{x}]", .{ @tagName(pl.reg), pl.off }), + .indirect_load_frame => |pl| try writer.print("[[{} + 0x{x}]]", .{ pl.index, pl.off }), .load_frame => |pl| try writer.print("[{} + 0x{x}]", .{ pl.index, pl.off }), .lea_frame => |pl| try writer.print("{} + 0x{x}", .{ pl.index, pl.off }), .load_nav => |pl| try writer.print("[nav:{d}]", .{@intFromEnum(pl)}), @@ -621,6 +587,7 @@ const InstTracking = struct { .undef, .immediate, .memory, + .indirect_load_frame, .load_frame, .lea_frame, .load_nav, @@ -724,6 +691,7 @@ const InstTracking = struct { .undef, .immediate, .memory, + .indirect_load_frame, .lea_frame, .load_nav, .lea_nav, @@ -795,9 +763,9 @@ const InstTracking = struct { } } - fn die(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index) !void { + fn die(self: *InstTracking, function: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void { if (self.short == .dead) return; - try function.freeValue(self.short); + try function.freeValue(self.short, opts); if (self.long == .none) self.long = self.short; self.short = .{ .dead = function.scope_generation }; tracking_log.debug("{} => {} (death)", .{ inst, self.* }); @@ -2356,13 +2324,12 @@ fn genBodyBlock(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { - @setEvalBranchQuota(28_700); + @setEvalBranchQuota(29_400); const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; const air_tags = cg.air.instructions.items(.tag); const air_datas = cg.air.instructions.items(.data); - const use_old = cg.target.ofmt == .coff; for (body) |inst| { if (cg.liveness.isUnused(inst) and !cg.air.mustLower(inst, ip)) continue; @@ -2372,17 +2339,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { cg.reused_operands = .initEmpty(); try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); switch (air_tags[@intFromEnum(inst)]) { - // zig fmt: off - .select => try cg.airSelect(inst), + .select => try cg.airSelect(inst), .shuffle_one, .shuffle_two => @panic("x86_64 TODO: shuffle_one/shuffle_two"), - // zig fmt: on .arg => try cg.airArg(inst), - .add, .add_optimized, .add_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) { - else => unreachable, - .add, .add_optimized => .add, - .add_wrap => .add_wrap, - }) else { + .add, .add_optimized, .add_wrap => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -3393,7 +3354,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -3527,8 +3492,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -3563,8 +3528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -3600,8 +3565,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -3640,8 +3605,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -4021,6 +3986,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -4051,6 +4017,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, .f_p, .add, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -4082,6 +4086,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87, .none } }, + .{ .src = .{ .to_x87, .to_x87, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -4115,6 +4158,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .add, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -4123,7 +4207,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -4157,8 +4245,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -4192,8 +4280,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -4227,8 +4315,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -4273,7 +4361,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .add_safe => unreachable, - .add_sat => |air_tag| if (use_old) try cg.airAddSat(inst) else { + .add_sat => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -12838,11 +12926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .sub, .sub_optimized, .sub_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) { - else => unreachable, - .sub, .sub_optimized => .sub, - .sub_wrap => .sub_wrap, - }) else { + .sub, .sub_optimized, .sub_wrap => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -13825,7 +13909,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -13959,8 +14047,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } }, .unused, .unused, @@ -13995,8 +14083,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } }, .unused, .unused, @@ -14032,8 +14120,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -14072,8 +14160,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subhf3" } }, .unused, .unused, @@ -14442,6 +14530,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -14472,6 +14561,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, .f_p, .sub, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -14501,6 +14628,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .subr, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -14531,6 +14695,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .to_x87, .none } }, + .{ .src = .{ .to_x87, .to_x87, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .sub, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -14564,6 +14766,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .sub, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -14572,7 +14815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -14606,8 +14853,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } }, .unused, .unused, @@ -14641,8 +14888,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } }, .unused, .unused, @@ -14676,8 +14923,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__subtf3" } }, .unused, .unused, @@ -14722,7 +14969,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .sub_safe => unreachable, - .sub_sat => |air_tag| if (use_old) try cg.airSubSat(inst) else { + .sub_sat => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -21556,7 +21803,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .mul, .mul_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mul) else { + .mul, .mul_optimized => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -23355,7 +23602,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -23489,8 +23740,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -23525,8 +23776,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -23562,8 +23813,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -23602,8 +23853,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -23983,6 +24234,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -24013,6 +24265,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, .f_p, .mul, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -24044,6 +24334,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87, .none } }, + .{ .src = .{ .to_x87, .to_x87, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -24077,6 +24406,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .mul, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -24085,7 +24455,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -24119,8 +24493,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -24154,8 +24528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -24189,8 +24563,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -24223,7 +24597,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .mul_safe => unreachable, - .mul_wrap => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { + .mul_wrap => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -26047,7 +26421,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -26181,8 +26559,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -26217,8 +26595,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -26254,8 +26632,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -26294,8 +26672,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -26777,7 +27155,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -26811,8 +27193,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -26846,8 +27228,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -26881,8 +27263,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -26922,9 +27304,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .mul_sat => |air_tag| if (use_old) try cg.airMulSat(inst) else fallback: { + .mul_sat => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airMulSat(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -32140,11 +32521,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) { - else => unreachable, - .div_float, .div_float_optimized => .div_float, - .div_exact, .div_exact_optimized => .div_exact, - }) else { + .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -32187,7 +32564,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -32321,8 +32702,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .unused, .unused, @@ -32357,8 +32738,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .unused, .unused, @@ -32394,8 +32775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -32434,8 +32815,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .unused, .unused, @@ -32805,6 +33186,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -32835,6 +33217,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -32864,6 +33284,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -32894,6 +33351,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .mem, .to_x87, .none } }, + .{ .src = .{ .to_x87, .to_x87, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -32927,6 +33422,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -32935,7 +33471,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -32969,8 +33509,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .unused, .unused, @@ -33004,8 +33544,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .unused, .unused, @@ -33039,8 +33579,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .unused, .unused, @@ -33075,7 +33615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { + .div_trunc => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -33121,7 +33661,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -33265,8 +33809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } }, .unused, @@ -33302,8 +33846,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } }, .unused, @@ -33340,8 +33884,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -33381,8 +33925,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunch" } }, .unused, @@ -33448,7 +33992,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -33515,7 +34059,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "truncf" } }, .unused, .unused, @@ -33661,7 +34205,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -33691,7 +34235,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -33842,7 +34390,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "trunc" } }, .unused, .unused, @@ -33877,8 +34425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "trunc" } }, .unused, @@ -33903,6 +34451,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -33936,6 +34486,88 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -33973,6 +34605,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncx" } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ }, + .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -33981,7 +34699,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -34016,8 +34738,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "truncq" } }, .unused, @@ -34052,8 +34774,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "truncq" } }, .unused, @@ -34088,8 +34810,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "truncq" } }, .unused, @@ -34124,11 +34846,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .div_trunc_optimized, .div_floor_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) { - else => unreachable, - .div_trunc_optimized => .div_trunc, - .div_floor_optimized => .div_floor, - }) else { + .div_trunc_optimized, .div_floor_optimized => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -34177,7 +34895,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -34319,8 +35041,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -34360,8 +35082,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -34402,8 +35124,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -34447,8 +35169,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -34518,7 +35240,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -34589,7 +35311,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .zero => "truncf", @@ -34739,7 +35461,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -34773,7 +35495,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -34928,7 +35654,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .zero => "trunc", @@ -34967,8 +35693,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -34997,6 +35723,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -35004,7 +35732,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .mem, .mem, .none } }, + .{ .src = .{ .to_mem, .to_mem, .none } }, }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ @@ -35034,6 +35762,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -35041,12 +35771,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .to_x87, .mem, .none } }, + .{ .src = .{ .to_mem, .to_mem, .none } }, }, - .call_frame = .{ .size = 16, .alignment = .@"16" }, + .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, - .{ .type = .f80, .kind = .{ .frame = .call_frame } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .zero => "__truncx", @@ -35058,18 +35790,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, .unused, - .unused, - .unused, }, - .dst_temps = .{ .{ .reg = .st0 }, .unused }, + .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, - .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, - .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -35077,13 +35812,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .mem, .to_x87, .none } }, - .{ .src = .{ .to_x87, .to_x87, .none } }, + .{ .src = .{ .to_mem, .to_mem, .none } }, }, - .call_frame = .{ .size = 16, .alignment = .@"16" }, + .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, - .{ .type = .f80, .kind = .{ .frame = .call_frame } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .zero => "__truncx", @@ -35094,19 +35831,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, .unused, - .unused, - .unused, - .unused, }, - .dst_temps = .{ .{ .reg = .st0 }, .unused }, + .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, - .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, - .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -35148,6 +35893,100 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { + else => unreachable, + .zero => "__truncx", + .down => "__floorx", + } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { + else => unreachable, + .zero => "__truncx", + .down => "__floorx", + } } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ }, + .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -35156,7 +35995,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -35195,8 +36038,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -35235,8 +36078,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -35275,8 +36118,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -35314,7 +36157,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { + .div_floor => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -35460,15 +36303,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .adc, .dst0q, .si(-1), ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ .mem, .mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, @@ -35479,7 +36322,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0q0, .mem(.src0q), ._, ._ }, @@ -35515,10 +36358,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } }, .{ .kind = .{ .mem_of_type = .dst0 } }, @@ -35597,7 +36440,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -35741,8 +36588,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } }, .unused, @@ -35778,8 +36625,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } }, .unused, @@ -35816,8 +36663,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -35857,8 +36704,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divhf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "__floorh" } }, .unused, @@ -35924,7 +36771,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -35991,7 +36838,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "floorf" } }, .unused, .unused, @@ -36137,7 +36984,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -36167,7 +37014,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -36318,7 +37169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "floor" } }, .unused, .unused, @@ -36353,8 +37204,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divdf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "floor" } }, .unused, @@ -36379,6 +37230,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -36412,6 +37265,88 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp2t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp3p, .tmp2p, ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .mem(.dst0), ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -36449,6 +37384,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .gnu, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp3t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp4p, .tmp3p, ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_cc_abi = .win64, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floorx" } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .ld, .memia(.src1t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .div, ._, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp1, .add_unaligned_size), ._, ._ }, + .{ ._, .f_p, .st, .lea(.tmp4t), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp5p, .tmp4p, ._, ._ }, + .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -36457,7 +37478,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -36492,8 +37517,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "floorq" } }, .unused, @@ -36528,8 +37553,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "floorq" } }, .unused, @@ -36564,8 +37589,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divtf3" } }, .{ .type = .usize, .kind = .{ .extern_func = "floorq" } }, .unused, @@ -36598,7 +37623,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .rem, .rem_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .rem) else { + .rem, .rem_optimized => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -36712,12 +37737,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .div, .src1q, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } }, .none, } }, }, @@ -36735,18 +37760,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } }, .none, } }, }, @@ -36764,11 +37817,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", null, null, null }, .src_constraints = .{ @@ -36781,10 +37862,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } }, .unused, .unused, @@ -36814,10 +37895,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } }, .unused, .unused, @@ -37166,7 +38247,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, @@ -37178,12 +38259,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } }, - .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -37204,7 +38285,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, @@ -37216,12 +38297,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } }, - .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -37254,10 +38335,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } }, .unused, .unused, @@ -37290,10 +38371,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } }, .unused, .unused, @@ -37321,7 +38402,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -37355,8 +38440,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .unused, .unused, @@ -37391,8 +38476,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .unused, .unused, @@ -37428,8 +38513,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -37468,8 +38553,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .unused, .unused, @@ -37502,7 +38587,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -37536,8 +38625,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } }, .unused, .unused, @@ -37571,8 +38660,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } }, .unused, .unused, @@ -37601,7 +38690,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -37635,8 +38728,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .unused, .unused, @@ -37670,8 +38763,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .unused, .unused, @@ -37705,8 +38798,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .unused, .unused, @@ -37730,6 +38823,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37741,7 +38835,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37763,6 +38857,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37774,7 +38869,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37796,6 +38891,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37807,7 +38903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37829,6 +38925,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37841,7 +38970,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37867,6 +38996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37879,7 +39009,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37905,6 +39035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -37917,7 +39048,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .unused, @@ -37942,6 +39073,41 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ @@ -37950,7 +39116,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -37984,8 +39154,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .unused, .unused, @@ -38019,8 +39189,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .unused, .unused, @@ -38054,8 +39224,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .unused, .unused, @@ -38087,7 +39257,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .mod, .mod_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mod) else { + .mod, .mod_optimized => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -38383,14 +39553,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .div, .src1q, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .cmov, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .cmov, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, @@ -38402,7 +39573,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ }, @@ -38422,14 +39593,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .to_mem, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .to_mem, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__modti3" } }, .unused, .unused, @@ -38441,7 +39612,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .dst0q1, .mem(.src1q), ._, ._ }, @@ -38459,12 +39630,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .adc, .dst0q1, .src0q0, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } }, .none, } }, }, @@ -38482,7 +39653,65 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__umodti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -38499,10 +39728,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "__modei4" } }, .unused, @@ -38557,10 +39786,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__umodei4" } }, .unused, .unused, @@ -38586,7 +39815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38627,7 +39860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38668,7 +39905,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38706,7 +39947,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38744,7 +39989,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38782,7 +40031,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38820,7 +40073,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38858,7 +40115,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -38901,9 +40162,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -38949,9 +40210,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -38997,9 +40258,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39042,9 +40303,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39087,9 +40348,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39132,9 +40393,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39177,9 +40438,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39223,9 +40484,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f16, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f16, .kind = .{ .reg = .dx } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -39271,8 +40532,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, @@ -39320,8 +40581,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodh" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, @@ -39362,7 +40623,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39400,7 +40665,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39438,7 +40707,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39480,8 +40753,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } }, .{ .type = .f32, .kind = .{ .reg = .edx } }, @@ -39524,8 +40797,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } }, .{ .type = .f32, .kind = .{ .reg = .edx } }, @@ -39568,8 +40841,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodf" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .f32, .kind = .{ .reg = .eax } }, @@ -39605,7 +40878,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39644,7 +40921,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39683,7 +40964,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -39730,8 +41015,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f64, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .{ .type = .f64, .kind = .{ .reg = .rcx } }, @@ -39775,8 +41060,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f64, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .{ .type = .f64, .kind = .{ .reg = .rcx } }, @@ -39820,8 +41105,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmod" } }, .{ .type = .f64, .kind = .{ .reg = .rdx } }, .{ .type = .f64, .kind = .mem }, @@ -39857,6 +41142,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -39868,7 +41155,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -39900,6 +41187,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .avx, .x87, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -39911,7 +41200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -39943,6 +41232,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -39954,7 +41245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -39986,6 +41277,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse2, .x87, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -39997,7 +41290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40029,6 +41322,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40040,7 +41335,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40072,6 +41367,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse, .x87, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40083,7 +41380,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40115,6 +41412,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .add, ._, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .avx, .x87, .fast_imm16 }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40127,7 +41426,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40163,6 +41462,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .avx, .x87, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40175,7 +41476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40211,6 +41512,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse2, .x87, .fast_imm16 }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40223,7 +41526,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40259,6 +41562,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse2, .x87, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40271,7 +41576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40307,6 +41612,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse, .x87, .fast_imm16 }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40319,7 +41626,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40355,6 +41662,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, + .required_cc_abi = .sysv64, .required_features = .{ .@"64bit", .sse, .x87, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -40367,7 +41676,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmodx" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -40410,7 +41719,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -40451,7 +41764,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -40492,7 +41809,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -40534,7 +41855,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -40579,8 +41904,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .{ .type = .f128, .kind = .{ .reg = .rcx } }, .{ .type = .f128, .kind = .{ .reg = .rdx } }, @@ -40625,8 +41950,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .{ .type = .f128, .kind = .{ .reg = .rcx } }, .{ .type = .f128, .kind = .{ .reg = .rdx } }, @@ -40671,8 +41996,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .{ .type = .f128, .kind = .{ .reg = .rcx } }, .{ .type = .f128, .kind = .{ .reg = .rdx } }, @@ -40718,8 +42043,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmodq" } }, .{ .type = .f128, .kind = .{ .reg = .rdx } }, .{ .type = .f128, .kind = .mem }, @@ -40761,7 +42086,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { + .ptr_add => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -40817,7 +42142,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .patterns = &.{ .{ .src = .{ .to_gpr, .to_gpr, .none } }, }, - .dst_temps = .{ .{ .ref = .src1 }, .unused }, + .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused }, .each = .{ .once = &.{ .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, @@ -40838,7 +42163,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .patterns = &.{ .{ .src = .{ .to_gpr, .to_gpr, .none } }, }, - .dst_temps = .{ .{ .ref = .src1 }, .unused }, + .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .unused }, .each = .{ .once = &.{ .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, @@ -40875,7 +42200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } else res[0] = ops[0]; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .ptr_sub => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { + .ptr_sub => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -41004,7 +42329,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } else res[0] = ops[0]; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { + .max => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -43810,7 +45135,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -43950,8 +45279,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -43986,8 +45315,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -44023,8 +45352,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -44063,8 +45392,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -44476,7 +45805,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -44733,8 +46066,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmax" } }, .unused, .unused, @@ -45020,7 +46353,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -45054,8 +46391,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -45089,8 +46426,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -45124,8 +46461,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -45157,7 +46494,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { + .min => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -47969,7 +49306,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -48109,8 +49450,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -48145,8 +49486,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -48182,8 +49523,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -48222,8 +49563,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -48635,7 +49976,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -48892,8 +50237,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmin" } }, .unused, .unused, @@ -49167,7 +50512,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .any, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -49201,8 +50550,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -49236,8 +50585,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -49271,8 +50620,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -49304,10 +50653,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .add_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: { + .add_with_overflow => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ @@ -50155,10 +51503,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].withOverflow(&res[1], cg); try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .sub_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: { + .sub_with_overflow => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ @@ -51061,10 +52408,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].withOverflow(&res[1], cg); try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .mul_with_overflow => |air_tag| if (use_old) try cg.airMulWithOverflow(inst) else fallback: { + .mul_with_overflow => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airMulWithOverflow(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ @@ -54659,10 +56005,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].withOverflow(&res[1], cg); try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .shl_with_overflow => |air_tag| if (use_old) try cg.airShlWithOverflow(inst) else fallback: { + .shl_with_overflow => |air_tag| { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlWithOverflow(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ @@ -55515,7 +56860,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -55579,7 +56924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -55643,7 +56988,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -55707,7 +57052,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -55771,7 +57116,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -55827,7 +57172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -55883,7 +57228,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -55939,7 +57284,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -55995,7 +57340,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56059,7 +57404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56123,7 +57468,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56187,7 +57532,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56251,7 +57596,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56308,7 +57653,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56365,7 +57710,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56422,7 +57767,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56479,7 +57824,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56549,7 +57894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56619,7 +57964,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56689,7 +58034,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -56759,7 +58104,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56821,7 +58166,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56883,7 +58228,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -56945,7 +58290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -57007,7 +58352,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -57069,7 +58414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -57131,7 +58476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -57193,7 +58538,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp4q, ._, ._ }, @@ -57255,7 +58600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -57325,7 +58670,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -57395,7 +58740,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -57465,7 +58810,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -57535,7 +58880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57596,7 +58941,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57657,7 +59002,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57718,7 +59063,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57779,7 +59124,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57840,7 +59185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57901,7 +59246,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -57962,7 +59307,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -58005,7 +59350,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].withOverflow(&res[1], cg); try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .alloc => if (use_old) try cg.airAlloc(inst) else { + .alloc => { const ty = air_datas[@intFromEnum(inst)].ty; const slot = try cg.tempInit(ty, .{ .lea_frame = .{ .index = try cg.allocMemPtr(inst), @@ -58013,7 +59358,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try slot.finish(inst, &.{}, &.{}, cg); }, .inferred_alloc, .inferred_alloc_comptime => unreachable, - .ret_ptr => if (use_old) try cg.airRetPtr(inst) else { + .ret_ptr => { const ty = air_datas[@intFromEnum(inst)].ty; var slot = switch (cg.ret_mcv.long) { else => unreachable, @@ -58029,7 +59374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try slot.finish(inst, &.{}, &.{}, cg); }, .assembly => try cg.airAsm(inst), - .bit_and, .bit_or, .xor, .bool_and, .bool_or => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { + .bit_and, .bit_or, .xor, .bool_and, .bool_or => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -58399,9 +59744,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .shr, .shr_exact => |air_tag| if (use_old) try cg.airShlShrBinOp(inst) else fallback: { + .shr, .shr_exact => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlShrBinOp(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -58964,9 +60308,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .shl, .shl_exact => |air_tag| if (use_old) try cg.airShlShrBinOp(inst) else fallback: { + .shl, .shl_exact => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airShlShrBinOp(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -59339,10 +60682,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .shl_sat => |air_tag| if (use_old) try cg.airShlSat(inst) else fallback: { + .shl_sat => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const lhs_ty = cg.typeOf(bin_op.lhs); - if (lhs_ty.isVector(zcu)) break :fallback try cg.airShlSat(inst); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; switch (ops[1].tracking(cg).short) { @@ -61190,7 +62532,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -61274,7 +62616,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -61357,7 +62699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -61427,7 +62769,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -61498,7 +62840,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -61583,7 +62925,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -61667,7 +63009,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -61738,7 +63080,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -61810,7 +63152,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -61901,7 +63243,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .mov, .tmp5q, .tmp3q, ._, ._ }, @@ -61992,7 +63334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62070,7 +63412,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62148,7 +63490,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62226,7 +63568,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62304,7 +63646,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -62394,7 +63736,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memad(.src0q, .add_size, -8), ._, ._ }, .{ ._, ._, .mov, .tmp4q, .lea(.tmp2q), ._, ._ }, .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, @@ -62484,7 +63826,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62561,7 +63903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62638,7 +63980,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62715,7 +64057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, .{ ._, ._, .sub, .tmp1d, .tmp0d, ._, ._ }, - .{ ._, ._, .lea, .tmp2p, .memsi(.src0q, .@"8", .tmp1), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memsi(.src0, .@"8", .tmp1), ._, ._ }, .{ ._, ._, .mov, .tmp3q, .lea(.tmp2q), ._, ._ }, .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, .{ ._, ._ld, .sh, .tmp4q, .tmp3q, .src1b, ._ }, @@ -62763,7 +64105,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .not => |air_tag| if (use_old) try cg.airUnOp(inst, air_tag) else { + .not => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -64003,7 +65345,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.lowerBlock(inst, @ptrCast(cg.air.extra.items[block.end..][0..block.data.body_len])); if (!cg.mod.strip) try cg.asmPseudo(.pseudo_dbg_leave_block_none); }, - .loop => if (use_old) try cg.airLoop(inst) else { + .loop => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const block = cg.air.extraData(Air.Block, ty_pl.payload); try cg.loops.putNoClobber(cg.gpa, inst, .{ @@ -64027,14 +65369,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .br => try cg.airBr(inst), .trap => try cg.asmOpOnly(.{ ._2, .ud }), .breakpoint => try cg.asmOpOnly(.{ ._3, .int }), - .ret_addr => if (use_old) try cg.airRetAddr(inst) else { + .ret_addr => { var slot = try cg.tempInit(.usize, .{ .load_frame = .{ .index = .ret_addr, } }); while (try slot.toRegClass(true, .general_purpose, cg)) {} try slot.finish(inst, &.{}, &.{}, cg); }, - .frame_addr => if (use_old) try cg.airFrameAddress(inst) else { + .frame_addr => { const slot = try cg.tempInit(.usize, .{ .lea_frame = .{ .index = .base_ptr, } }); @@ -64044,7 +65386,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_always_tail => try cg.airCall(inst, .always_tail, .{ .safety = true }), .call_never_tail => try cg.airCall(inst, .never_tail, .{ .safety = true }), .call_never_inline => try cg.airCall(inst, .never_inline, .{ .safety = true }), - .clz => |air_tag| if (use_old) try cg.airClz(inst) else { + .clz => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -67149,9 +68491,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .ctz => |air_tag| if (use_old) try cg.airCtz(inst) else fallback: { + .ctz => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; - if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airCtz(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -67547,9 +68888,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .popcount => |air_tag| if (use_old) try cg.airPopCount(inst) else fallback: { + .popcount => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; - if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airPopCount(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -68436,9 +69776,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .byte_swap => |air_tag| if (use_old) try cg.airByteSwap(inst) else fallback: { + .byte_swap => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; - if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airByteSwap(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -69086,9 +70425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .bit_reverse => |air_tag| if (use_old) try cg.airBitReverse(inst) else fallback: { + .bit_reverse => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; - if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airByteSwap(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -72189,7 +73527,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .sqrt => |air_tag| if (use_old) try cg.airSqrt(inst) else { + .sqrt => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -72209,7 +73547,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -72294,7 +73632,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } }, .unused, .unused, @@ -72325,7 +73663,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } }, .unused, .unused, @@ -72356,7 +73694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -72390,7 +73728,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__sqrth" } }, .unused, .unused, @@ -72459,7 +73797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -72578,7 +73916,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } }, .unused, .unused, @@ -72608,7 +73946,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrtf" } }, .unused, .unused, @@ -72675,7 +74013,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -72794,7 +74132,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } }, .unused, .unused, @@ -72824,7 +74162,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } }, .unused, .unused, @@ -72854,7 +74192,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrt" } }, .unused, .unused, @@ -72877,6 +74215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -72903,6 +74242,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .mem, .none, .none } }, + .{ .src = .{ .to_x87, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }, .unused }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, .f_, .sqrt, ._, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -72931,11 +74304,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fn_cw, .st, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memd(.tmp0b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp0b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp0b, 1), .tmp1b, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_, .sqrt, ._, ._, ._, ._ }, + .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp0w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -72965,7 +74374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } }, .unused, .unused, @@ -72995,7 +74404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } }, .unused, .unused, @@ -73025,7 +74434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "sqrtq" } }, .unused, .unused, @@ -73056,7 +74465,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| if (use_old) try cg.airUnaryMath(inst, air_tag) else { + .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -73066,7 +74475,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -73095,8 +74504,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } }, .unused, .unused, @@ -73110,13 +74519,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0p, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -73126,8 +74535,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } }, .unused, .unused, @@ -73141,13 +74550,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -73157,8 +74566,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -73172,14 +74581,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -73189,10 +74598,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "h" } }, .unused, .unused, @@ -73204,22 +74613,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -73248,8 +74657,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } }, .unused, .unused, @@ -73263,12 +74672,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -73278,8 +74687,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "f" } }, .unused, .unused, @@ -73293,18 +74702,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -73333,8 +74742,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } }, .unused, .unused, @@ -73348,12 +74757,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -73363,8 +74772,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } }, .unused, .unused, @@ -73378,12 +74787,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -73393,8 +74802,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) } }, .unused, .unused, @@ -73408,15 +74817,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73424,7 +74834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73444,6 +74854,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73451,7 +74862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73471,6 +74882,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73478,7 +74890,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73498,6 +74910,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73505,8 +74945,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73520,16 +74960,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73537,8 +74978,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73552,16 +74993,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -73569,8 +75011,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, .unused, @@ -73584,20 +75026,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__" ++ @tagName(name) ++ "x" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -73626,8 +75098,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } }, .unused, .unused, @@ -73641,12 +75113,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -73656,8 +75128,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } }, .unused, .unused, @@ -73671,12 +75143,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -73686,8 +75158,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = @tagName(name) ++ "q" } }, .unused, .unused, @@ -73701,12 +75173,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }, }) catch |err| switch (err) { @@ -73719,7 +75191,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .abs => |air_tag| if (use_old) try cg.airAbs(inst) else { + .abs => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -75270,12 +76742,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .floor, .ceil, .trunc_float => |air_tag| if (use_old) try cg.airRound(inst, .{ .direction = switch (air_tag) { - else => unreachable, - .floor => .down, - .ceil => .up, - .trunc_float => .zero, - }, .precision = .inexact }) else { + .floor, .ceil, .trunc_float => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -75302,7 +76769,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -75392,7 +76859,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "__floorh", @@ -75428,7 +76895,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "__floorh", @@ -75464,7 +76931,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "__floorh", @@ -75503,7 +76970,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "__floorh", @@ -75577,7 +77044,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -75707,7 +77174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floorf", @@ -75742,7 +77209,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floorf", @@ -75814,7 +77281,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -75944,7 +77411,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floor", @@ -75979,7 +77446,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floor", @@ -76014,7 +77481,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floor", @@ -76042,6 +77509,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76049,7 +77517,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76074,6 +77542,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76081,7 +77550,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76106,6 +77575,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76113,7 +77583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76138,6 +77608,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { + else => unreachable, + .down => "__floorx", + .up => "__ceilx", + .zero => "__truncx", + } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76146,7 +77649,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76175,6 +77678,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76183,7 +77687,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76212,6 +77716,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .patterns = &.{ @@ -76220,7 +77725,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, @@ -76248,11 +77753,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { + else => unreachable, + .down => "__floorx", + .up => "__ceilx", + .zero => "__truncx", + } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -76287,7 +77827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floorq", @@ -76322,7 +77862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floorq", @@ -76357,7 +77897,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = switch (direction) { else => unreachable, .down => "floorq", @@ -76394,7 +77934,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .neg, .neg_optimized => |air_tag| if (use_old) try cg.airFloatSign(inst, .neg) else { + .neg, .neg_optimized => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -76942,7 +78482,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .cmp_gte_optimized, .cmp_gt, .cmp_gt_optimized, - => |air_tag| if (use_old) try cg.airCmp(inst, air_tag.toCmpOp().?) else { + => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const cmp_op = air_tag.toCmpOp().?; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -76991,7 +78531,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -77334,7 +78878,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -77378,7 +78926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .cmp_eq_optimized, .cmp_neq, .cmp_neq_optimized, - => |air_tag| if (use_old) try cg.airCmp(inst, air_tag.toCmpOp().?) else { + => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const cmp_op = air_tag.toCmpOp().?; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -77495,7 +79043,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -77862,7 +79414,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .none, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -77939,7 +79495,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { + .cmp_vector, .cmp_vector_optimized => |air_tag| fallback: { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const vector_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; switch (vector_cmp.compareOperator()) { @@ -78533,8 +80089,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78577,8 +80133,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78621,8 +80177,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78666,8 +80222,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78711,8 +80267,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78758,8 +80314,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78805,8 +80361,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78858,8 +80414,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78911,8 +80467,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -78965,8 +80521,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -79019,8 +80575,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -79075,8 +80631,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -79902,8 +81458,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -79946,8 +81502,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -79990,8 +81546,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80034,8 +81590,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80078,8 +81634,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80122,8 +81678,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80166,8 +81722,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80219,8 +81775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80272,8 +81828,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80325,8 +81881,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80378,8 +81934,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -80431,8 +81987,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83041,8 +84597,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83085,8 +84641,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83129,8 +84685,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83174,8 +84730,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83219,8 +84775,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83266,8 +84822,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83313,8 +84869,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83366,8 +84922,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83419,8 +84975,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83473,8 +85029,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83527,8 +85083,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -83583,8 +85139,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmphf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84424,8 +85980,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84468,8 +86024,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84512,8 +86068,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84556,8 +86112,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84600,8 +86156,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84644,8 +86200,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84688,8 +86244,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84741,8 +86297,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84794,8 +86350,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84847,8 +86403,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84900,8 +86456,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -84953,8 +86509,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__cmptf2" } }, .{ .type = .i32, .kind = .{ .reg = .eax } }, .{ .type = .u8, .kind = .{ .reg = .cl } }, @@ -85048,7 +86604,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .data = .{ .ip_index = old_inline_func }, }); }, - .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (use_old) try cg.airDbgVar(inst) else if (!cg.mod.strip) { + .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (!cg.mod.strip) { const pl_op = air_datas[@intFromEnum(inst)].pl_op; const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); const op_ty = cg.typeOf(pl_op.operand); @@ -85086,7 +86642,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.genLocalDebugInfo(air_tag, local_ty, ops[0].tracking(cg).short); try ops[0].die(cg); }, - .is_null => if (use_old) try cg.airIsNull(inst) else { + .is_null => { const un_op = air_datas[@intFromEnum(inst)].un_op; const opt_ty = cg.typeOf(un_op); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); @@ -85111,7 +86667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_null = try cg.tempInit(.bool, .{ .eflags = .e }); try is_null.finish(inst, &.{un_op}, &ops, cg); }, - .is_non_null => if (use_old) try cg.airIsNonNull(inst) else { + .is_non_null => { const un_op = air_datas[@intFromEnum(inst)].un_op; const opt_ty = cg.typeOf(un_op); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); @@ -85136,7 +86692,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne }); try is_non_null.finish(inst, &.{un_op}, &ops, cg); }, - .is_null_ptr => if (use_old) try cg.airIsNullPtr(inst) else { + .is_null_ptr => { const un_op = air_datas[@intFromEnum(inst)].un_op; const opt_ty = cg.typeOf(un_op).childType(zcu); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); @@ -85159,7 +86715,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_null = try cg.tempInit(.bool, .{ .eflags = .e }); try is_null.finish(inst, &.{un_op}, &ops, cg); }, - .is_non_null_ptr => if (use_old) try cg.airIsNonNullPtr(inst) else { + .is_non_null_ptr => { const un_op = air_datas[@intFromEnum(inst)].un_op; const opt_ty = cg.typeOf(un_op).childType(zcu); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); @@ -85182,7 +86738,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne }); try is_non_null.finish(inst, &.{un_op}, &ops, cg); }, - .is_err => if (use_old) try cg.airIsErr(inst) else { + .is_err => { const un_op = air_datas[@intFromEnum(inst)].un_op; const eu_ty = cg.typeOf(un_op); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -85198,7 +86754,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); try is_err.finish(inst, &.{un_op}, &ops, cg); }, - .is_non_err => if (use_old) try cg.airIsNonErr(inst) else { + .is_non_err => { const un_op = air_datas[@intFromEnum(inst)].un_op; const eu_ty = cg.typeOf(un_op); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -85214,7 +86770,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, - .is_err_ptr => if (use_old) try cg.airIsErrPtr(inst) else { + .is_err_ptr => { const un_op = air_datas[@intFromEnum(inst)].un_op; const eu_ty = cg.typeOf(un_op).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -85232,7 +86788,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); try is_err.finish(inst, &.{un_op}, &ops, cg); }, - .is_non_err_ptr => if (use_old) try cg.airIsNonErrPtr(inst) else { + .is_non_err_ptr => { const un_op = air_datas[@intFromEnum(inst)].un_op; const eu_ty = cg.typeOf(un_op).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -85250,7 +86806,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, - .load => if (use_old) try cg.airLoad(inst) else fallback: { + .load => fallback: { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const val_ty = ty_op.ty.toType(); const ptr_ty = cg.typeOf(ty_op.operand); @@ -85299,7 +86855,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { for (ops) |op| try op.die(cg); }, .unreach => {}, - .fptrunc => |air_tag| if (use_old) try cg.airFptrunc(inst) else { + .fptrunc => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -85341,7 +86897,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -85370,7 +86926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -85385,11 +86941,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .mova, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .mova, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -85400,8 +86956,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } }, .unused, .unused, @@ -85415,12 +86971,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -85431,8 +86987,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } }, .unused, .unused, @@ -85446,12 +87002,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -85462,8 +87018,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -85477,13 +87033,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -85494,8 +87050,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncsfhf2" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -85509,21 +87065,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -85553,8 +87109,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } }, .unused, .unused, @@ -85568,12 +87124,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -85584,8 +87140,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } }, .unused, .unused, @@ -85599,12 +87155,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -85615,8 +87171,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -85630,13 +87186,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -85647,8 +87203,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncdfhf2" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -85662,15 +87218,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -85777,7 +87333,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -85792,11 +87348,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ }, + .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -85806,7 +87362,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -85821,11 +87377,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -85835,7 +87391,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -85850,13 +87406,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -85877,7 +87434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, @@ -85885,6 +87442,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -85905,7 +87463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, @@ -85913,6 +87471,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -85933,7 +87492,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, @@ -85941,6 +87500,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -85949,8 +87537,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, .unused, @@ -85964,15 +87552,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -85981,8 +87602,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, .unused, @@ -85996,15 +87617,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -86013,8 +87667,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -86028,16 +87682,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .reg = .ax } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .tmp4d, .tmp3x, .ui(0), ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, @@ -86046,8 +87734,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -86061,15 +87749,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__truncxfhf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .mem }, + .{ .type = .f16, .kind = .{ .reg = .ax } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .tmp5d, .mem(.tmp4d), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -86105,7 +87827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -86120,11 +87842,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -86160,7 +87882,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -86175,18 +87897,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86216,8 +87938,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } }, .unused, .unused, @@ -86231,12 +87953,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -86247,8 +87969,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } }, .unused, .unused, @@ -86262,12 +87984,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -86278,8 +88000,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -86293,13 +88015,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -86310,8 +88032,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfhf2" } }, .{ .type = .f32, .kind = .mem }, .{ .type = .f16, .kind = .{ .reg = .ax } }, @@ -86325,21 +88047,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86369,8 +88091,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } }, .unused, .unused, @@ -86384,12 +88106,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -86400,8 +88122,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } }, .unused, .unused, @@ -86415,12 +88137,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -86431,8 +88153,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfsf2" } }, .unused, .unused, @@ -86446,19 +88168,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86488,8 +88210,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } }, .unused, .unused, @@ -86503,12 +88225,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -86519,8 +88241,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } }, .unused, .unused, @@ -86534,12 +88256,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -86550,8 +88272,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfdf2" } }, .unused, .unused, @@ -86565,19 +88287,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86599,6 +88322,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm1 }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -86607,8 +88359,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, .unused, .unused, @@ -86622,15 +88374,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -86639,8 +88424,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, .unused, .unused, @@ -86654,15 +88439,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -86671,8 +88489,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, .unused, .unused, @@ -86686,13 +88504,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__trunctfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sa(.dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._ps, .mova, .tmp2x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @@ -86705,7 +88555,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .fpext => |air_tag| if (use_old) try cg.airFpext(inst) else { + .fpext => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -86749,7 +88599,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86778,7 +88628,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -86793,11 +88643,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -86808,8 +88658,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } }, .unused, .unused, @@ -86823,13 +88673,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -86840,8 +88690,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } }, .unused, .unused, @@ -86855,13 +88705,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -86872,10 +88722,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfsf2" } }, .unused, .unused, @@ -86887,14 +88737,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -86969,7 +88819,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -86998,7 +88848,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, .unused, @@ -87013,15 +88863,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, .{ ._, .v_f128, .extract, .tmp1x, .tmp1y, .ui(1), ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp2y, ._, ._ }, .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, - .{ ._, .v_pd, .mova, .memsiad(.dst0y, .@"4", .tmp0, .add_unaligned_size, 32), .tmp2y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsid(.dst0y, .@"4", .tmp0, 32), .tmp2y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -87032,8 +88882,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } }, .unused, .unused, @@ -87047,13 +88897,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -87064,8 +88914,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } }, .unused, .unused, @@ -87079,13 +88929,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -87096,10 +88946,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfdf2" } }, .unused, .unused, @@ -87111,14 +88961,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, .x87, null, null }, @@ -87148,11 +88998,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -87174,6 +89025,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm1 }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -87182,8 +89062,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, .unused, .unused, @@ -87197,16 +89077,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ }, + .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, + .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memi(.src0w, .tmp0), .ui(0) }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -87215,8 +89129,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, .unused, .unused, @@ -87230,16 +89144,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ }, + .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, + .{ ._, .p_w, .insr, .tmp2x, .memi(.src0w, .tmp0), .ui(0), ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -87248,10 +89196,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, .unused, .unused, @@ -87263,22 +89211,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .reg = .ax } }, + .{ .type = .f32, .kind = .mem }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendhfxf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .mem(.tmp3d), .tmp2d, ._, ._ }, + .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp3d), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -87308,8 +89290,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } }, .unused, .unused, @@ -87323,13 +89305,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -87340,8 +89322,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } }, .unused, .unused, @@ -87355,13 +89337,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -87372,10 +89354,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendhftf2" } }, .unused, .unused, @@ -87387,14 +89369,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -87501,7 +89483,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -87516,11 +89498,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -87530,7 +89512,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -87545,11 +89527,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -87559,7 +89541,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -87574,11 +89556,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0q, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -87613,7 +89595,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -87628,18 +89610,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -87669,8 +89651,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } }, .unused, .unused, @@ -87684,12 +89666,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -87700,8 +89682,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } }, .unused, .unused, @@ -87715,12 +89697,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -87731,8 +89713,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendsftf2" } }, .unused, .unused, @@ -87746,12 +89728,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -87786,7 +89768,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -87801,18 +89783,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -87842,8 +89824,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } }, .unused, .unused, @@ -87857,12 +89839,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -87873,8 +89855,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } }, .unused, .unused, @@ -87888,12 +89870,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -87904,8 +89886,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__extenddftf2" } }, .unused, .unused, @@ -87919,15 +89901,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -87948,7 +89931,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, @@ -87956,6 +89939,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -87976,7 +89960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, @@ -87984,6 +89968,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -88004,7 +89989,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, @@ -88012,6 +89997,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -88020,8 +90034,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, .unused, @@ -88035,15 +90049,80 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -88052,8 +90131,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, .unused, @@ -88067,15 +90146,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, @@ -88084,8 +90164,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, .unused, @@ -88099,13 +90179,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__extendxftf2" } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @@ -88118,7 +90230,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .intcast => |air_tag| if (use_old) try cg.airIntCast(inst) else { + .intcast => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const dst_ty = ty_op.ty.toType(); const src_ty = cg.typeOf(ty_op.operand); @@ -92797,7 +94909,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .intcast_safe => unreachable, - .trunc => |air_tag| if (use_old) try cg.airTrunc(inst) else { + .trunc => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -98462,7 +100574,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .optional_payload => if (use_old) try cg.airOptionalPayload(inst) else { + .optional_payload => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBitsIgnoreComptime(zcu)) @@ -98471,12 +100583,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.tempInit(ty_op.ty.toType(), .none); try pl.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .optional_payload_ptr => if (use_old) try cg.airOptionalPayloadPtr(inst) else { + .optional_payload_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .optional_payload_ptr_set => if (use_old) try cg.airOptionalPayloadPtrSet(inst) else { + .optional_payload_ptr_set => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); @@ -98491,7 +100603,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .wrap_optional => if (use_old) try cg.airWrapOptional(inst) else { + .wrap_optional => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const opt_ty = ty_op.ty.toType(); const opt_pl_ty = cg.typeOf(ty_op.operand); @@ -98506,7 +100618,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try opt.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .unwrap_errunion_payload => if (use_old) try cg.airUnwrapErrUnionPayload(inst) else { + .unwrap_errunion_payload => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_pl_ty = ty_op.ty.toType(); const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); @@ -98517,7 +100629,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.tempInit(eu_pl_ty, .none); try pl.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .unwrap_errunion_err => if (use_old) try cg.airUnwrapErrUnionErr(inst) else { + .unwrap_errunion_err => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand); const eu_err_ty = ty_op.ty.toType(); @@ -98527,7 +100639,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const err = try ops[0].read(eu_err_ty, .{ .disp = eu_err_off }, cg); try err.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .unwrap_errunion_payload_ptr => if (use_old) try cg.airUnwrapErrUnionPayloadPtr(inst) else { + .unwrap_errunion_payload_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -98536,7 +100648,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].toOffset(eu_pl_off, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .unwrap_errunion_err_ptr => if (use_old) try cg.airUnwrapErrUnionErrPtr(inst) else { + .unwrap_errunion_err_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_err_ty = ty_op.ty.toType(); @@ -98547,7 +100659,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const err = try ops[0].load(eu_err_ty, .{}, cg); try err.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .errunion_payload_ptr_set => if (use_old) try cg.airErrUnionPayloadPtrSet(inst) else { + .errunion_payload_ptr_set => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -98562,7 +100674,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].toOffset(eu_pl_off - eu_err_off, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .wrap_errunion_payload => if (use_old) try cg.airWrapErrUnionPayload(inst) else { + .wrap_errunion_payload => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const eu_err_ty = eu_ty.errorUnionSet(zcu); @@ -98577,7 +100689,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try err.die(cg); try eu.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .wrap_errunion_err => if (use_old) try cg.airWrapErrUnionErr(inst) else { + .wrap_errunion_err => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -98587,7 +100699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try eu.write(&ops[0], .{ .disp = eu_err_off }, cg); try eu.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else { + .struct_field_ptr => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand}); @@ -98602,13 +100714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .struct_field_ptr_index_1, .struct_field_ptr_index_2, .struct_field_ptr_index_3, - => |air_tag| if (use_old) try cg.airStructFieldPtrIndex(inst, switch (air_tag) { - else => unreachable, - .struct_field_ptr_index_0 => 0, - .struct_field_ptr_index_1 => 1, - .struct_field_ptr_index_2 => 2, - .struct_field_ptr_index_3 => 3, - }) else { + => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(cg.fieldOffset( @@ -98624,14 +100730,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { ), cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: { + .struct_field_val => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; const agg_ty = cg.typeOf(struct_field.struct_operand); const field_ty = ty_pl.ty.toType(); const field_off: u31 = switch (agg_ty.containerLayout(zcu)) { .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(struct_field.field_index, zcu)), - .@"packed" => break :fallback try cg.airStructFieldVal(inst), + .@"packed" => unreachable, }; var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand}); var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu)) @@ -98640,7 +100746,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.tempInit(field_ty, .none); try res.finish(inst, &.{struct_field.struct_operand}, &ops, cg); }, - .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else { + .set_union_tag => { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const union_ty = cg.typeOf(bin_op.lhs).childType(zcu); const union_layout = union_ty.unionGetLayout(zcu); @@ -98651,7 +100757,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const res = try cg.tempInit(.void, .none); try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .get_union_tag => if (use_old) try cg.airGetUnionTag(inst) else { + .get_union_tag => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; const union_ty = cg.typeOf(ty_op.operand); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); @@ -98662,38 +100768,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, cg); try res.finish(inst, &.{ty_op.operand}, &ops, cg); }, - .slice => if (use_old) try cg.airSlice(inst) else { + .slice => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toPair(&ops[1], cg); try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .slice_len => if (use_old) try cg.airSliceLen(inst) else { + .slice_len => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toSliceLen(cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .slice_ptr => if (use_old) try cg.airSlicePtr(inst) else { + .slice_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toSlicePtr(cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .ptr_slice_len_ptr => if (use_old) try cg.airPtrSliceLenPtr(inst) else { + .ptr_slice_len_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(8, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .ptr_slice_ptr_ptr => if (use_old) try cg.airPtrSlicePtrPtr(inst) else { + .ptr_slice_ptr_ptr => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(0, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .array_elem_val => if (use_old) try cg.airArrayElemVal(inst) else { + .array_elem_val => { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const array_ty = cg.typeOf(bin_op.lhs); const res_ty = array_ty.elemType2(zcu); @@ -98889,11 +100995,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .slice_elem_val, .ptr_elem_val => |air_tag| if (use_old) switch (air_tag) { - else => unreachable, - .slice_elem_val => try cg.airSliceElemVal(inst), - .ptr_elem_val => try cg.airPtrElemVal(inst), - } else { + .slice_elem_val, .ptr_elem_val => { const bin_op = air_datas[@intFromEnum(inst)].bin_op; const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -99016,11 +101118,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } else res[0] = try cg.tempInit(res_ty, .none); try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .slice_elem_ptr, .ptr_elem_ptr => |air_tag| if (use_old) switch (air_tag) { - else => unreachable, - .slice_elem_ptr => try cg.airSliceElemPtr(inst), - .ptr_elem_ptr => try cg.airPtrElemPtr(inst), - } else { + .slice_elem_ptr, .ptr_elem_ptr => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -99067,7 +101165,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, - .array_to_slice => if (use_old) try cg.airArrayToSlice(inst) else { + .array_to_slice => { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var len = try cg.tempInit(.usize, .{ @@ -99076,7 +101174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].toPair(&len, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .int_from_float, .int_from_float_optimized => |air_tag| if (use_old) try cg.airIntFromFloat(inst) else { + .int_from_float, .int_from_float_optimized => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -99278,7 +101376,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99294,7 +101392,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .eax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -99304,7 +101402,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99320,7 +101418,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .eax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -99330,7 +101428,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99346,7 +101444,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .rax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -99356,7 +101454,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99372,17 +101470,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .rax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99398,17 +101497,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .word }, .any, .any }, + .dst_constraints = .{ .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .word }, .any, .any }, + .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99424,7 +101578,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -99434,7 +101588,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99465,7 +101619,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .word }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -99527,7 +101681,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -99544,13 +101698,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, .v_ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, .v_, .cvttps2dq, .tmp3x, .tmp3x, ._, ._ }, .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, - .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -99561,10 +101715,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99576,13 +101730,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -99593,10 +101747,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99608,13 +101762,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -99625,10 +101779,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99640,13 +101794,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -99657,10 +101811,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99672,13 +101826,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -99689,10 +101843,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, .unused, .unused, @@ -99704,14 +101858,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -99722,10 +101876,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, .unused, .unused, @@ -99737,14 +101891,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -99782,7 +101936,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -99797,13 +101951,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -99813,7 +101967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -99828,13 +101982,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -99845,10 +101999,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99860,13 +102014,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -99877,10 +102031,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -99892,13 +102046,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -99909,10 +102063,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, .unused, .unused, @@ -99924,14 +102078,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -99941,7 +102095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -99956,12 +102110,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -99971,7 +102125,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .rc = .sse } }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .unused, @@ -99986,14 +102140,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ }, .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp2d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -100004,10 +102158,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100019,13 +102173,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -100036,10 +102190,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100051,13 +102205,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -100068,10 +102222,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100083,13 +102237,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -100100,10 +102254,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100115,13 +102269,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -100132,10 +102286,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfsi" } }, .unused, .unused, @@ -100147,14 +102301,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -100165,10 +102319,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfsi" } }, .unused, .unused, @@ -100180,14 +102334,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp1d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .f16c, null, null }, @@ -100197,7 +102351,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .rc = .sse } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, @@ -100212,14 +102366,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ }, .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp2q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -100230,10 +102384,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100245,13 +102399,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -100262,10 +102416,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100277,13 +102431,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -100294,10 +102448,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100309,13 +102463,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -100326,10 +102480,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -100341,13 +102495,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -100358,10 +102512,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfdi" } }, .unused, .unused, @@ -100373,14 +102527,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -100391,10 +102545,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfdi" } }, .unused, .unused, @@ -100406,16 +102560,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100424,11 +102579,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -100439,16 +102594,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100457,11 +102646,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -100472,16 +102661,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100490,11 +102713,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -100505,16 +102728,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100523,11 +102780,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -100538,16 +102795,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100556,12 +102847,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .unused, .unused, .unused, .unused, @@ -100571,17 +102862,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ }, + .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .mem }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixhfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -100590,12 +102916,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .unused, .unused, .unused, .unused, @@ -100605,15 +102931,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d0, .memi(.src0w, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .tmp1d0, ._, ._ }, + .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"8", .tmp0, 8), .tmp1q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .mem }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -100624,11 +102984,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } }, .unused, .unused, @@ -100639,16 +102999,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -100659,11 +103019,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } }, .unused, .unused, @@ -100674,16 +103034,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -100694,11 +103054,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } }, .unused, .unused, @@ -100709,16 +103069,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -100729,11 +103089,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } }, .unused, .unused, @@ -100744,16 +103104,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp4x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -100764,12 +103124,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixhfei" } }, .unused, .unused, @@ -100779,17 +103139,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -100800,12 +103160,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunshfei" } }, .unused, .unused, @@ -100815,17 +103175,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp3d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -100940,11 +103300,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -100960,17 +103321,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -100986,17 +103375,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -101024,7 +103441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, - .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, @@ -101033,11 +103450,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, + .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, + .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ }, + .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, .v_q, .mov, .tmp1q, .src0x, ._, ._ }, + .{ ._, .vp_q, .extr, .tmp4q, .src0x, .ui(1), ._ }, + .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, + .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, + .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, + .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -101065,7 +103527,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, - .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, @@ -101074,7 +103536,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, + .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, + .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ }, + .{ ._, .p_q, .extr, .tmp4q, .src0x, .ui(1), ._ }, + .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, + .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, + .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, + .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, + .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, + .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ }, + .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._q, .mov, .tmp1q, .src0x, ._, ._ }, + .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b11_10), ._ }, + .{ ._, ._q, .mov, .tmp4q, .src0x, ._, ._ }, + .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, + .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, + .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, + .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, + .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -101082,7 +103634,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .i64, .kind = .{ .reg = .rax } }, .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, @@ -101106,7 +103658,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ }, .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, .{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q, ._, ._ }, .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ }, .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ }, .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, @@ -101115,17 +103667,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .dword }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .u64, .kind = .{ .reg = .rax } }, .{ .type = .usize, .kind = .{ .reg = .rdi } }, .{ .type = .u32, .kind = .{ .reg = .ecx } }, .unused, @@ -101134,16 +103686,113 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, .unused, + .unused, }, .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, - .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, - .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ }, + .{ ._, .v_dqa, .mov, .mem(.dst0x), .src0x, ._, ._ }, .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, - .{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ }, - .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .mem(.dst0x), .src0x, ._, ._ }, + .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + .{ ._, ._, .mov, .mem(.dst0q), .tmp1q0, ._, ._ }, + .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q1, ._, ._ }, + .{ ._, ._, .xor, .tmp1d0, .tmp1d0, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, + .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .float = .dword }, .any, .any }, + .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .usize, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .reg = .ecx } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .mem(.dst0x), .src0x, ._, ._ }, + .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memd(.dst0, 16), ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, } }, }, .{ @@ -101208,7 +103857,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -101225,12 +103874,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, - .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .ssse3, null, null, null }, @@ -101240,7 +103889,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -101257,12 +103906,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ }, - .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -101272,7 +103921,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -101287,11 +103936,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -101301,7 +103950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -101316,11 +103965,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -101331,10 +103980,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101346,12 +103995,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101362,10 +104011,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101377,12 +104026,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -101393,10 +104042,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101408,12 +104057,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -101424,10 +104073,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101439,12 +104088,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101506,7 +104155,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101521,12 +104170,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -101536,7 +104185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101551,12 +104200,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101566,7 +104215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101581,12 +104230,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -101596,7 +104245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101611,12 +104260,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101627,10 +104276,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101642,12 +104291,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -101658,10 +104307,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101673,12 +104322,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101712,7 +104361,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101727,11 +104376,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -101741,7 +104390,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -101756,11 +104405,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101771,10 +104420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101786,12 +104435,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101802,10 +104451,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101817,12 +104466,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -101833,10 +104482,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101848,12 +104497,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -101864,10 +104513,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101879,12 +104528,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -101894,7 +104543,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -101909,11 +104558,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -101923,7 +104572,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -101938,11 +104587,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttss2si, .tmp1q, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101953,10 +104602,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101968,12 +104617,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -101984,10 +104633,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -101999,12 +104648,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -102015,10 +104664,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -102030,12 +104679,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -102046,10 +104695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -102061,14 +104710,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -102077,11 +104727,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -102092,15 +104742,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -102109,11 +104792,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -102124,15 +104807,112 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -102141,11 +104921,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -102156,15 +104936,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixsfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -102173,11 +104986,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -102188,13 +105001,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"4", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -102205,11 +105050,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } }, .unused, .unused, @@ -102220,15 +105065,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -102239,11 +105084,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } }, .unused, .unused, @@ -102254,15 +105099,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -102273,11 +105118,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfei" } }, .unused, .unused, @@ -102288,15 +105133,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -102307,11 +105152,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunssfei" } }, .unused, .unused, @@ -102322,15 +105167,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ss, .mov, .tmp4x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -102643,11 +105488,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .qword }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -102663,17 +105509,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .qword }, .any, .any }, + .dst_constraints = .{ .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .qword }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -102689,7 +105563,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .qword }, .any, .any }, + .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ref = .src0 }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -102699,12 +105600,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .qword }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } }, .unused, .unused, @@ -102727,12 +105628,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .qword }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } }, .unused, .unused, @@ -102839,7 +105740,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -102856,22 +105757,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsia(.src0y, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsi(.src0y, .@"8", .tmp0), ._, ._ }, .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, - .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_d, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .ssse3, null, null, null }, + .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any }, .patterns = &.{ .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, @@ -102888,12 +105789,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ }, - .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .ssse3, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, + .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, + .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ }, + .{ ._, ._d, .mov, .tmp4d, .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp4w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -102903,7 +105837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -102918,11 +105852,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -102932,7 +105866,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -102947,11 +105881,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp1b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, .slow_incdec, null, null }, @@ -102961,7 +105895,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, @@ -102976,18 +105910,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -102998,7 +105932,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, @@ -103013,18 +105947,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"8", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .tmp4b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp2b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -103036,10 +105970,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103051,12 +105985,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -103067,10 +106001,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103082,12 +106016,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -103098,10 +106032,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103113,12 +106047,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103129,10 +106063,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103144,12 +106078,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -103160,10 +106094,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103175,13 +106109,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -103192,10 +106126,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixsfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103207,13 +106141,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp0), .tmp3b, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -103301,7 +106235,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103316,12 +106250,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ }, .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103331,7 +106265,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103346,12 +106280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -103361,7 +106295,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103376,12 +106310,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"4", .tmp0), ._, ._ }, .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_q, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -103391,7 +106325,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103406,12 +106340,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._d, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103421,7 +106355,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -103436,11 +106370,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -103450,7 +106384,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, .unused, @@ -103470,11 +106404,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -103485,7 +106419,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, @@ -103500,18 +106434,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"4", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -103523,10 +106457,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103538,12 +106472,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103554,10 +106488,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103569,12 +106503,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -103585,10 +106519,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103600,13 +106534,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -103652,7 +106586,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103667,11 +106601,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsi(.src0y, .@"2", .tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103681,7 +106615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -103696,11 +106630,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, + .{ ._, ._q, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -103710,7 +106644,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, .unused, @@ -103730,11 +106664,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -103745,7 +106679,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, @@ -103760,18 +106694,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0q, .@"2", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -103783,10 +106717,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103798,12 +106732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -103814,10 +106748,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103829,12 +106763,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103845,10 +106779,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103860,12 +106794,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -103876,10 +106810,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103891,12 +106825,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -103907,10 +106841,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103922,13 +106856,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -103939,10 +106873,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -103954,13 +106888,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -103970,7 +106904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -103985,11 +106919,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -103999,7 +106933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, .unused, .unused, @@ -104014,11 +106948,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp1q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -104028,7 +106962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f64, .kind = .{ .reg = .st7 } }, .unused, @@ -104048,11 +106982,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -104064,10 +106998,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104079,12 +107013,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -104095,10 +107029,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104110,12 +107044,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -104126,10 +107060,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104141,12 +107075,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -104157,10 +107091,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104172,12 +107106,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -104188,10 +107122,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104203,13 +107137,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -104220,10 +107154,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -104235,15 +107169,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104252,11 +107187,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104267,15 +107202,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104284,11 +107252,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104299,15 +107267,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104316,11 +107317,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104331,15 +107332,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104348,11 +107382,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104363,15 +107397,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104380,11 +107447,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104395,16 +107462,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, @@ -104413,11 +107514,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -104428,14 +107529,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memsid(.dst0q, .@"2", .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -104446,11 +107580,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } }, .unused, .unused, @@ -104461,15 +107595,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -104480,11 +107614,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } }, .unused, .unused, @@ -104495,15 +107629,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -104514,11 +107648,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } }, .unused, .unused, @@ -104529,15 +107663,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -104548,11 +107682,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } }, .unused, .unused, @@ -104563,15 +107697,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._sd, .mov, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -104582,11 +107716,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixdfei" } }, .unused, .unused, @@ -104597,16 +107731,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -104617,11 +107751,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsdfei" } }, .unused, .unused, @@ -104632,16 +107766,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp4x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse3, .x87, null, null }, @@ -104772,7 +107906,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i16, .kind = .mem }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, @@ -104786,15 +107920,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse3, .x87, null, null }, @@ -104805,7 +107939,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i16, .kind = .mem }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, @@ -104819,15 +107953,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, .slow_incdec, null, null }, @@ -104838,7 +107972,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -104852,8 +107986,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ }, @@ -104862,10 +107996,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ }, .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, } }, }, .{ @@ -104877,7 +108011,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -104891,8 +108025,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ }, @@ -104901,10 +108035,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ }, .{ ._, ._, .movsx, .tmp3d, .tmp5b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, } }, }, .{ @@ -104916,7 +108050,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, @@ -104930,15 +108064,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse3, .x87, null, null }, @@ -104949,7 +108083,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, @@ -104963,15 +108097,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, .slow_incdec, null, null }, @@ -104982,7 +108116,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -104996,8 +108130,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ }, @@ -105006,10 +108140,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, } }, }, .{ @@ -105021,7 +108155,7 @@ 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 = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -105035,8 +108169,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_00), ._, ._ }, @@ -105045,10 +108179,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp5w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp3d, .tmp5b, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp3b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, } }, }, .{ @@ -105117,7 +108251,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -105132,11 +108266,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .stt, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .stt, .memi(.dst0w, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -105146,7 +108280,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -105166,11 +108300,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0w, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -105181,7 +108315,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i32, .kind = .mem }, .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, @@ -105196,13 +108330,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp2d, ._, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -105212,7 +108346,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -105227,18 +108361,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"8", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4d, ._, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp2w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -105307,7 +108441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -105322,11 +108456,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .stt, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .stt, .memi(.dst0d, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -105336,7 +108470,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -105356,11 +108490,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0d, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -105371,7 +108505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .i64, .kind = .mem }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, @@ -105386,13 +108520,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .stt, .tmp2q, ._, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -105402,7 +108536,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, @@ -105417,18 +108551,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"4", .tmp0), ._, ._, ._ }, .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp2d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ @@ -105490,6 +108624,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .@"64bit", .sse3, .x87, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any }, @@ -105526,6 +108661,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .@"64bit", .x87, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any }, @@ -105567,6 +108703,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .@"64bit", .x87, null, null }, + .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, + .dst_constraints = .{ .{ .exact_unsigned_int = 64 }, .any }, + .patterns = &.{ + .{ .src = .{ .mem, .none, .none } }, + .{ .src = .{ .to_x87, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, + .{ .type = .i64, .kind = .mem }, + .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .tmp0t, ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .dst0d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_11_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .dst0b, ._, ._ }, + .{ ._, ._, .lea, .dst0q, .mem(.tmp3), ._, ._ }, + .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ }, + .{ ._, .f_, .sub, .lea(.dst0d), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp5q, .tmp4q, ._, ._ }, + .{ ._, .fi_p, .st, .tmp4q, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .dst0q, .tmp5q, ._, ._ }, + .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, + .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, + .{ ._, ._, .@"or", .dst0q, .tmp5q, ._, ._ }, + } }, }, .{ .required_features = .{ .sse3, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, @@ -105575,7 +108754,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -105590,11 +108769,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .stt, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .stt, .memi(.dst0q, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -105604,7 +108783,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .u16, .kind = .mem }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -105624,15 +108803,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_11_00), ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp0b, ._, ._ }, - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .fi_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memsi(.src0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, .fi_p, .st, .memi(.dst0q, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -105640,11 +108820,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, - .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -105655,16 +108835,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -105672,11 +108853,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, - .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -105687,16 +108868,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -105704,11 +108886,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, - .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -105719,16 +108901,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfdi" } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ @@ -105736,7 +108950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, .unused, @@ -105748,7 +108962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, @@ -105756,7 +108970,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ @@ -105764,7 +108979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, .unused, @@ -105776,7 +108991,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, @@ -105784,7 +108999,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ @@ -105792,7 +109008,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, .unused, @@ -105804,7 +109020,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, @@ -105812,7 +109028,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ @@ -105820,7 +109037,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, .unused, @@ -105832,7 +109049,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, @@ -105840,7 +109057,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ @@ -105848,7 +109066,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, .unused, @@ -105860,7 +109078,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, @@ -105868,7 +109086,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ @@ -105876,7 +109095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, .unused, @@ -105888,7 +109107,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, @@ -105896,7 +109115,62 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, + .dst_constraints = .{ .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, + .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -105904,12 +109178,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -105919,17 +109193,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -105937,12 +109212,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -105952,17 +109227,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -105970,12 +109246,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -105985,17 +109261,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -106003,12 +109280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -106018,17 +109295,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -106036,12 +109314,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -106051,17 +109329,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -106069,12 +109348,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -106084,17 +109363,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp4q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106102,9 +109382,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106124,7 +109404,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106132,9 +109413,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106154,7 +109435,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106162,9 +109444,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106184,7 +109466,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106192,9 +109475,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106214,7 +109497,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106222,9 +109506,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106244,7 +109528,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106252,9 +109537,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106274,7 +109559,66 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, + .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, + .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106282,11 +109626,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106297,19 +109641,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106317,11 +109662,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106332,19 +109677,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106352,11 +109698,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106367,19 +109713,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106387,11 +109734,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106402,19 +109749,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106422,11 +109770,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, .unused, @@ -106437,19 +109785,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -106457,11 +109806,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, .unused, @@ -106472,16 +109821,84 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixxfei" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .dst_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunsxfei" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -106493,10 +109910,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106507,14 +109924,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -106526,10 +109943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106540,14 +109957,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -106559,10 +109976,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106573,14 +109990,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -106592,10 +110009,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106606,14 +110023,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -106625,10 +110042,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106639,14 +110056,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -106658,10 +110075,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106672,14 +110089,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .memad(.src0, .add_unaligned_size, -16), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-1, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp4b, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -106690,10 +110107,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106705,12 +110122,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -106721,10 +110138,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106736,12 +110153,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -106752,10 +110169,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106767,19 +110184,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"8", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp3w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -106795,7 +110212,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .eax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -106805,7 +110222,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -106821,7 +110238,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .eax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -106835,10 +110252,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106850,12 +110267,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -106866,10 +110283,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106881,12 +110298,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -106897,10 +110314,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106912,12 +110329,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -106928,10 +110345,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106943,12 +110360,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -106959,10 +110376,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfsi" } }, - .{ .type = .i32, .kind = .{ .reg = .eax } }, + .{ .type = .i32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -106974,12 +110391,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -106990,10 +110407,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfsi" } }, - .{ .type = .u32, .kind = .{ .reg = .eax } }, + .{ .type = .u32, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107005,19 +110422,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0d, .tmp0), .tmp3d, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -107033,7 +110450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .rax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -107043,7 +110460,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -107059,7 +110476,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .rax }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -107073,10 +110490,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107088,12 +110505,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -107104,10 +110521,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107119,12 +110536,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -107135,10 +110552,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107150,12 +110567,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -107166,10 +110583,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107181,12 +110598,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -107197,10 +110614,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfdi" } }, - .{ .type = .i64, .kind = .{ .reg = .rax } }, + .{ .type = .i64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107212,12 +110629,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -107228,10 +110645,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfdi" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -107243,19 +110660,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .signed_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -107271,17 +110689,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .xword }, .any, .any }, + .dst_constraints = .{ .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -107297,13 +110743,41 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg_pair = .{ .rax, .rdx } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .float = .xword }, .any, .any }, + .dst_constraints = .{ .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107311,11 +110785,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107326,16 +110800,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107343,11 +110850,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107358,16 +110865,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107375,11 +110915,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107390,16 +110930,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107407,11 +110980,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107422,16 +110995,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107439,11 +111045,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .i64, .kind = .{ .reg = .rdx } }, + .{ .type = .i128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107454,16 +111060,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixtfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -107471,11 +111110,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, - .{ .type = .u64, .kind = .{ .reg = .rax } }, - .{ .type = .u64, .kind = .{ .reg = .rdx } }, + .{ .type = .u128, .kind = .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -107486,25 +111125,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, - .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp3q0, ._, ._ }, + .{ ._, ._, .mov, .memid(.dst0q, .tmp0, 8), .tmp3q1, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfti" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } }, .unused, .unused, @@ -107527,12 +111198,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .float = .xword }, .any, .any }, .dst_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, + .{ .src = .{ .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } }, .unused, .unused, @@ -107559,11 +111230,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } }, .unused, .unused, @@ -107574,15 +111245,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -107593,11 +111264,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } }, .unused, .unused, @@ -107608,15 +111279,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -107627,11 +111298,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } }, .unused, .unused, @@ -107642,15 +111313,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -107661,11 +111332,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } }, .unused, .unused, @@ -107676,15 +111347,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -107695,11 +111366,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixtfei" } }, .unused, .unused, @@ -107710,15 +111381,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -107729,11 +111400,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fixunstfei" } }, .unused, .unused, @@ -107744,15 +111415,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mema(.dst0, .add_unaligned_size_sub_elem_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ }, - .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .mova, .tmp4x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .sub_dst0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @@ -107767,7 +111438,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .int_from_float_safe => unreachable, .int_from_float_optimized_safe => unreachable, - .float_from_int => |air_tag| if (use_old) try cg.airFloatFromInt(inst) else { + .float_from_int => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -107980,7 +111651,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -107996,7 +111667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ }, @@ -108007,7 +111678,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108023,7 +111694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ }, @@ -108034,7 +111705,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108050,7 +111721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ }, @@ -108061,7 +111732,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108077,7 +111748,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ }, @@ -108088,7 +111759,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108104,7 +111775,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -108114,7 +111785,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108130,7 +111801,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -108140,7 +111811,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108156,7 +111827,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -108166,7 +111837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108182,17 +111853,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108208,17 +111880,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .word }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .word }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -108234,11 +111935,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .word }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, @@ -108248,8 +111977,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } }, .unused, .unused, @@ -108260,7 +111989,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -108276,8 +112005,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } }, .unused, .unused, @@ -108288,7 +112017,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -108359,7 +112088,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -108374,12 +112103,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -108389,7 +112118,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -108404,12 +112133,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, .avx2, null, null }, @@ -108419,7 +112148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -108434,12 +112163,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memsi(.dst0x, .@"2", .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -108449,7 +112178,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -108464,12 +112193,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memsi(.dst0q, .@"2", .tmp0), .tmp1x, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -108480,10 +112209,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108495,12 +112224,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -108511,10 +112240,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108526,12 +112255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, .slow_incdec, null, null }, @@ -108542,10 +112271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108557,12 +112286,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -108573,10 +112302,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108588,12 +112317,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -108604,10 +112333,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108619,13 +112348,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -108636,10 +112365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108651,13 +112380,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -108668,10 +112397,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -108683,14 +112412,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -108701,10 +112430,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -108716,14 +112445,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -108734,10 +112463,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108749,12 +112478,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -108765,10 +112494,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108780,12 +112509,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, .slow_incdec, null, null }, @@ -108796,10 +112525,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108811,12 +112540,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -108827,10 +112556,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108842,12 +112571,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memsi(.dst0w, .@"2", .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -108858,10 +112587,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108873,13 +112602,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -108890,10 +112619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -108905,13 +112634,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -108922,10 +112651,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -108937,14 +112666,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -108955,10 +112684,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -108970,14 +112699,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memsi(.dst0w, .@"2", .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -109043,7 +112772,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109058,12 +112787,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -109073,7 +112802,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109088,12 +112817,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, .avx2, null, null }, @@ -109103,7 +112832,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109118,12 +112847,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -109133,7 +112862,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109148,12 +112877,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -109164,10 +112893,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109179,12 +112908,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -109195,10 +112924,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109210,12 +112939,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -109226,10 +112955,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109241,13 +112970,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -109258,10 +112987,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -109273,14 +113002,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -109291,10 +113020,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109306,12 +113035,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -109322,10 +113051,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109337,12 +113066,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -109353,10 +113082,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109368,13 +113097,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -109385,10 +113114,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -109400,14 +113129,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -109443,7 +113172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109458,11 +113187,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsi(.src0y, .@"2", .tmp0), ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .f16c, null, null, null }, @@ -109472,7 +113201,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109487,11 +113216,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsi(.src0x, .@"2", .tmp0), ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0q, .tmp0), .tmp1x, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -109502,10 +113231,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109517,12 +113246,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -109533,10 +113262,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109548,12 +113277,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -109564,10 +113293,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109579,13 +113308,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -109596,10 +113325,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -109611,14 +113340,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -109629,10 +113358,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109644,12 +113373,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -109660,10 +113389,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109675,12 +113404,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -109691,10 +113420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109706,13 +113435,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -109723,10 +113452,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -109738,14 +113467,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memsi(.src0d, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .f16c, null, null }, @@ -109755,7 +113484,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -109770,13 +113499,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._ }, + .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"4", .tmp0), ._ }, .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -109787,10 +113516,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109802,12 +113531,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse4_1, null, null }, @@ -109818,10 +113547,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109833,12 +113562,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -109849,10 +113578,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109864,13 +113593,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -109881,10 +113610,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -109896,14 +113625,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -109914,10 +113643,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109929,12 +113658,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse4_1, null, null }, @@ -109945,10 +113674,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109960,12 +113689,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -109976,10 +113705,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -109991,13 +113720,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -110008,10 +113737,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -110023,17 +113752,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110041,11 +113771,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110056,16 +113786,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse4_1, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110073,11 +113804,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110088,16 +113819,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110105,11 +113836,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110120,17 +113851,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110138,33 +113869,167 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, .unused, .unused, .unused, + .unused, }, .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .mem }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110172,11 +114037,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110187,16 +114052,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse4_1, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110204,11 +114070,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110219,16 +114085,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110236,11 +114102,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -110251,17 +114117,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse4_1, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, .patterns = &.{ @@ -110269,30 +114135,163 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp3x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .tmp1d0, .tmp3x, .ui(0), ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, .unused, .unused, .unused, + .unused, }, .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ }, - .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"8", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .tmp1d0, .mem(.tmp4d), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w0, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntihf" } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .mem }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .mem(.tmp4d), .tmp3x, ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .mem(.tmp4d), ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -110304,11 +114303,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110318,15 +114317,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse4_1, null, null }, @@ -110338,11 +114337,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110352,15 +114351,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -110372,11 +114371,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110386,16 +114385,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -110407,11 +114406,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -110421,17 +114420,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -110443,11 +114442,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110457,15 +114456,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse4_1, null, null }, @@ -110477,11 +114476,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110491,15 +114490,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp1), .tmp5x, .ui(0), ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -110511,11 +114510,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -110525,16 +114524,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -110546,11 +114545,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneihf" } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f16, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f32, .kind = .mem }, .unused, .unused, @@ -110560,17 +114559,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-2, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ }, .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp1), .tmp2w, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -110965,11 +114964,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -110985,17 +114985,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .dword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .dword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -111011,11 +115040,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .dword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, @@ -111025,8 +115082,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } }, .unused, .unused, @@ -111037,7 +115094,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -111053,8 +115110,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } }, .unused, .unused, @@ -111065,7 +115122,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -111158,7 +115215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111173,12 +115230,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111188,7 +115245,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111203,12 +115260,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -111218,7 +115275,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111233,12 +115290,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .p_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -111248,7 +115305,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111263,12 +115320,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111278,7 +115335,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111293,12 +115350,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -111308,7 +115365,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111323,12 +115380,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .p_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -111339,10 +115396,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111354,12 +115411,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111370,10 +115427,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111385,12 +115442,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -111401,10 +115458,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111416,12 +115473,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -111432,10 +115489,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111447,12 +115504,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -111463,10 +115520,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111478,12 +115535,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111494,10 +115551,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111509,12 +115566,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -111525,10 +115582,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111540,12 +115597,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -111556,10 +115613,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111571,12 +115628,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111664,7 +115721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111679,12 +115736,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111694,7 +115751,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111709,12 +115766,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -111724,7 +115781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111739,12 +115796,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .p_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -111754,7 +115811,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111769,12 +115826,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111784,7 +115841,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111799,12 +115856,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -111814,7 +115871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -111829,12 +115886,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .p_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111845,10 +115902,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111860,12 +115917,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -111876,10 +115933,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111891,12 +115948,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -111907,10 +115964,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111922,12 +115979,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -111938,10 +115995,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -111953,12 +116010,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memsi(.dst0d, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -112004,7 +116061,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112019,11 +116076,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memi(.src0y, .tmp0), ._, ._ }, + .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -112033,7 +116090,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112048,11 +116105,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -112062,7 +116119,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112077,11 +116134,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, + .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -112091,7 +116148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112106,11 +116163,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -112121,10 +116178,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112136,12 +116193,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -112152,10 +116209,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112167,12 +116224,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -112183,10 +116240,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112198,12 +116255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -112214,10 +116271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112229,12 +116286,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -112244,7 +116301,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112259,12 +116316,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -112274,7 +116331,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -112289,12 +116346,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._ss, .cvtsi2, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .cvtsi2, .tmp1x, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -112305,10 +116362,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112320,12 +116377,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -112336,10 +116393,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112351,12 +116408,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -112367,10 +116424,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112382,12 +116439,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -112398,10 +116455,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112413,15 +116470,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -112429,11 +116487,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -112444,16 +116502,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -112461,11 +116520,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -112476,16 +116535,81 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattisf" } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -112493,11 +116617,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -112508,16 +116632,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, .patterns = &.{ @@ -112525,11 +116650,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -112540,13 +116665,77 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"4", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntisf" } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -112558,11 +116747,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112572,15 +116761,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -112592,11 +116781,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112606,15 +116795,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -112626,11 +116815,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112640,15 +116829,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -112660,11 +116849,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneisf" } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f32, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -112674,15 +116863,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-4, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -113295,11 +117484,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -113315,17 +117505,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .qword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .qword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -113341,11 +117560,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .qword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, @@ -113355,8 +117602,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } }, .unused, .unused, @@ -113367,7 +117614,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -113383,8 +117630,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } }, .unused, .unused, @@ -113395,7 +117642,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -113488,7 +117735,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113503,12 +117750,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -113518,7 +117765,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113533,14 +117780,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, .vp_d, .movsxb, .tmp1x, .tmp1d, ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -113550,7 +117797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113565,14 +117812,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, .p_d, .movsxb, .tmp1x, .tmp1d, ._, ._ }, .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -113582,7 +117829,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113597,12 +117844,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"8", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -113612,7 +117859,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113627,14 +117874,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memi(.src0w, .tmp0), .ui(0) }, .{ ._, .vp_d, .movzxb, .tmp1x, .tmp1d, ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -113644,7 +117891,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -113659,14 +117906,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, .{ ._, .p_d, .movzxb, .tmp1x, .tmp1d, ._, ._ }, .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -113677,10 +117924,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113692,12 +117939,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -113708,10 +117955,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113723,12 +117970,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -113739,10 +117986,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113754,12 +118001,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -113770,10 +118017,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113785,12 +118032,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -113801,10 +118048,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113816,12 +118063,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -113832,10 +118079,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113847,12 +118094,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -113863,10 +118110,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113878,12 +118125,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -113894,10 +118141,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113909,12 +118156,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -113925,10 +118172,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113940,12 +118187,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -113956,10 +118203,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -113971,12 +118218,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -113987,10 +118234,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114002,12 +118249,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -114018,10 +118265,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114033,12 +118280,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114126,7 +118373,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114141,12 +118388,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114156,7 +118403,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114171,13 +118418,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .vp_d, .movsxw, .tmp1x, .tmp1q, ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -114187,7 +118434,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114202,13 +118449,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .p_d, .movsxw, .tmp1x, .tmp1q, ._, ._ }, .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx2, null, null, null }, @@ -114218,7 +118465,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114233,12 +118480,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"4", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114248,7 +118495,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114263,13 +118510,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .vp_d, .movzxw, .tmp1x, .tmp1q, ._, ._ }, .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -114279,7 +118526,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114294,13 +118541,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_size), ._, ._ }, + .{ .@"0:", ._d, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, .p_d, .movzxw, .tmp1x, .tmp1q, ._, ._ }, .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114311,10 +118558,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114326,12 +118573,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -114342,10 +118589,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114357,12 +118604,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -114373,10 +118620,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114388,12 +118635,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114404,10 +118651,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114419,12 +118666,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -114435,10 +118682,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114450,12 +118697,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -114466,10 +118713,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114481,12 +118728,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114532,7 +118779,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114547,11 +118794,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0y, .@"2", .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114561,7 +118808,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114576,11 +118823,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, .v_pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -114590,7 +118837,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114605,11 +118852,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, + .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._pd, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114620,10 +118867,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114635,12 +118882,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -114651,10 +118898,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114666,12 +118913,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -114682,10 +118929,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114697,12 +118944,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -114713,10 +118960,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114728,12 +118975,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -114744,10 +118991,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114759,12 +119006,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -114775,10 +119022,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114790,12 +119037,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memsi(.dst0q, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -114805,7 +119052,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114820,12 +119067,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .v_pd, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, - .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memi(.src0q, .tmp0), ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -114835,7 +119082,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f64, .kind = .{ .rc = .sse } }, .unused, .unused, @@ -114850,12 +119097,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._pd, .xor, .tmp1x, .tmp1x, ._, ._ }, - .{ ._, ._sd, .cvtsi2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .cvtsi2, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -114866,10 +119113,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114881,12 +119128,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -114897,10 +119144,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114912,12 +119159,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -114928,10 +119175,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114943,12 +119190,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -114959,10 +119206,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -114974,12 +119221,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -114990,10 +119237,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115005,12 +119252,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -115021,10 +119268,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115036,15 +119283,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115052,11 +119300,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115067,16 +119315,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115084,11 +119333,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115099,16 +119348,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115116,11 +119365,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115131,16 +119380,114 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115148,11 +119495,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115163,16 +119510,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115180,11 +119528,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115195,16 +119543,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, .patterns = &.{ @@ -115212,11 +119560,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -115227,13 +119575,110 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memsi(.src0q, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memsid(.src0q, .@"2", .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntidf" } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.src0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0p, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -115245,11 +119690,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115259,15 +119704,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -115279,11 +119724,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115293,15 +119738,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -115313,11 +119758,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115327,15 +119772,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -115347,11 +119792,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115361,15 +119806,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -115381,11 +119826,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115395,15 +119840,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -115415,11 +119860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneidf" } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f64, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -115429,15 +119874,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-8, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -115627,6 +120072,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, @@ -115634,10 +120080,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, - .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, .unused, .unused, .unused, @@ -115650,18 +120096,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, + .{ ._, ._, .mov, .tmp3d, .memd(.src0d, 4), ._, ._ }, + .{ ._, ._r, .sh, .tmp3d, .ui(31), ._, ._ }, + .{ ._, .f_, .add, .leasi(.tmp1d, .@"4", .tmp3), ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ }, .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ }, - .{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memd(.tmp2b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp2b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp2b, 1), .tmp3b, ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .mem(.tmp4), ._, ._ }, + .{ ._, .f_, .add, .leasi(.tmp3d, .@"4", .tmp1), ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp2w, ._, ._, ._ }, .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -115683,11 +120167,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -115709,7 +120222,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .patterns = &.{ @@ -115717,8 +120259,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } }, .unused, .unused, @@ -115737,7 +120279,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .patterns = &.{ @@ -115745,8 +120318,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } }, .unused, .unused, @@ -115764,6 +120337,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_bit_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .x87, .slow_incdec, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, @@ -115772,7 +120375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .i16, .kind = .mem }, @@ -115787,15 +120390,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -115805,7 +120408,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .i16, .kind = .mem }, @@ -115820,15 +120423,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, .slow_incdec, null, null }, @@ -115838,7 +120441,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .i16, .kind = .mem }, @@ -115853,15 +120456,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -115871,7 +120474,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, .{ .type = .i16, .kind = .mem }, @@ -115886,17 +120489,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, .slow_incdec, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -115905,9 +120509,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -115920,17 +120524,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .required_features = .{ .slow_incdec, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -115939,9 +120578,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -115954,17 +120593,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .movsx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, .slow_incdec, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -115973,9 +120646,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -115988,17 +120661,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .slow_incdec, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -116007,9 +120715,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116022,15 +120730,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, + .{ ._, ._, .movzx, .tmp3d, .memi(.src0b, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -116040,7 +120781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -116055,13 +120796,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .fi_, .ld, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .fi_, .ld, .memi(.src0w, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -116070,8 +120812,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116085,15 +120827,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .movsx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -116102,8 +120876,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116117,13 +120891,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"8", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"8", .tmp0), ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memi(.src0w, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -116133,7 +120938,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -116148,13 +120953,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .fi_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .fi_, .ld, .memi(.src0d, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -116163,8 +120969,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116178,15 +120984,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, @@ -116195,8 +121033,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116210,13 +121048,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"4", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatunsixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"4", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2d, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .x87, null, null, null }, @@ -116226,7 +121095,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, .unused, @@ -116241,14 +121110,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .fi_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .fi_, .ld, .memi(.src0q, .tmp0), ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116256,8 +121126,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116271,16 +121141,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatdixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116288,8 +121190,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116303,16 +121205,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memsi(.dst0t, .@"2", .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatundixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memsi(.dst0, .@"2", .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp2q, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116320,9 +121254,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116331,21 +121264,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, .unused, + .unused, }, .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116353,9 +121319,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116364,21 +121329,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, .unused, + .unused, }, .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116387,9 +121385,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116401,19 +121399,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .x87, null, null }, + .required_cc_abi = .win64, + .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floateixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ }, + .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ }, + .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .x87, null, null, null }, .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, .patterns = &.{ @@ -116422,9 +121455,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, .unused, @@ -116436,16 +121469,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp1), ._, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuneixf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp2p, .memi(.dst0, .tmp1), ._, ._ }, + .{ ._, ._, .mov, .tmp3p, .tmp0p, ._, ._ }, + .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -116457,7 +121524,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, .unused, .unused, @@ -116469,7 +121536,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, @@ -116485,7 +121552,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, .unused, .unused, @@ -116497,7 +121564,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, @@ -116513,7 +121580,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, .unused, .unused, @@ -116525,7 +121592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, @@ -116541,7 +121608,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, .unused, .unused, @@ -116553,7 +121620,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, @@ -116564,7 +121631,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116580,7 +121647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -116590,7 +121657,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116606,7 +121673,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -116616,7 +121683,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116632,7 +121699,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -116642,7 +121709,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116658,17 +121725,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116684,17 +121752,46 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, .dst_constraints = .{ .{ .float = .xword }, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -116710,11 +121807,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, + .dst_constraints = .{ .{ .float = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, @@ -116724,8 +121849,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } }, .unused, .unused, @@ -116736,7 +121861,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -116752,8 +121877,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } }, .unused, .unused, @@ -116764,7 +121889,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, @@ -116780,11 +121905,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116795,14 +121920,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -116813,11 +121938,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116828,14 +121953,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -116846,11 +121971,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116861,14 +121986,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -116879,11 +122004,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116894,14 +122019,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -116912,11 +122037,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116927,14 +122052,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -116945,11 +122070,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116960,14 +122085,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, .slow_incdec, null, null }, @@ -116978,11 +122103,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -116993,14 +122118,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -117011,11 +122136,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117026,14 +122151,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, .slow_incdec, null, null }, @@ -117044,11 +122169,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117059,14 +122184,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -117077,11 +122202,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117092,14 +122217,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, .slow_incdec, null, null }, @@ -117110,11 +122235,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117125,14 +122250,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -117143,11 +122268,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117158,14 +122283,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .memad(.dst0, .add_unaligned_size, -16), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp2d, .memi(.src0b, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, - .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, - .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, - .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, -16), ._, ._ }, + .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, + .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -117176,10 +122301,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117191,12 +122316,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -117207,10 +122332,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117222,12 +122347,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -117238,10 +122363,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117253,12 +122378,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movsx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -117269,10 +122394,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117284,12 +122409,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -117300,10 +122425,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117315,12 +122440,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -117331,10 +122456,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117346,12 +122471,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"8", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -117362,10 +122487,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117377,12 +122502,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -117393,10 +122518,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117408,12 +122533,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -117424,10 +122549,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117439,12 +122564,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -117455,10 +122580,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117470,12 +122595,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -117486,10 +122611,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117501,12 +122626,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -117517,10 +122642,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u32, .kind = .{ .reg = .edi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunsitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117532,12 +122657,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1d, .memi(.src0d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"4", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -117548,10 +122673,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117563,12 +122688,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -117579,10 +122704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117594,12 +122719,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -117610,10 +122735,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .i64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117625,12 +122750,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -117641,10 +122766,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117656,12 +122781,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -117672,10 +122797,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117687,12 +122812,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -117703,10 +122828,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatunditf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117718,15 +122843,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memsi(.dst0x, .@"2", .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117734,11 +122860,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117749,16 +122875,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117766,11 +122893,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117781,16 +122908,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117798,11 +122925,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .i64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .i128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117813,16 +122940,114 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .avx, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floattitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117830,11 +123055,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117845,16 +123070,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse2, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117862,11 +123088,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117877,16 +123103,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, + .required_cc_abi = .sysv64, + .required_features = .{ .sse2, null, null, null }, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, .patterns = &.{ @@ -117894,11 +123120,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .reg = .rdi } }, - .{ .type = .u64, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, .unused, .unused, .unused, @@ -117909,13 +123135,110 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, - .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u128, .kind = .{ .param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .mov, .tmp1q0, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._, .mov, .tmp1q1, .memid(.src0q, .tmp0, 8), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, + .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__floatuntitf" } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp3x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -117927,11 +123250,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117941,15 +123264,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -117961,11 +123284,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -117975,15 +123298,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -117995,11 +123318,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floateitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -118009,15 +123332,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .avx, null, null }, @@ -118029,11 +123352,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -118043,15 +123366,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse2, null, null }, @@ -118063,11 +123386,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -118077,15 +123400,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .@"64bit", .sse, null, null }, @@ -118097,11 +123420,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .reg = .rdi } }, - .{ .type = .usize, .kind = .{ .reg = .rsi } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__floatuneitf" } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -118111,15 +123434,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, - .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, - .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, - .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp1), .tmp5x, ._, ._ }, + .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .sub_src0_elem_size), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @@ -118132,7 +123455,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .reduce => |air_tag| if (use_old) try cg.airReduce(inst) else { + .reduce => |air_tag| { const nan = std.math.nan(f16); const reduce = air_datas[@intFromEnum(inst)].reduce; const res_ty = cg.typeOfIndex(inst); @@ -131814,7 +137137,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -131825,7 +137148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -131847,7 +137170,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -131858,7 +137181,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -131882,7 +137205,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -131891,7 +137214,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -133482,7 +138805,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -133493,7 +138816,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -133513,7 +138836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -133524,7 +138847,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -133544,7 +138867,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -133555,7 +138878,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -141934,7 +147257,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -141945,7 +147268,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -141967,7 +147290,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -141978,7 +147301,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -142002,7 +147325,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -142011,7 +147334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -143610,7 +148933,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -143621,7 +148944,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -143641,7 +148964,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -143652,7 +148975,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -143672,7 +148995,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -143683,7 +149006,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -147548,7 +152871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -147581,7 +152904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -147605,7 +152928,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -147616,7 +152939,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -147638,7 +152961,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -147649,7 +152972,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -147673,7 +152996,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -147682,7 +153005,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -148150,6 +153473,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, @@ -148157,8 +153481,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st6 } }, .unused, .unused, @@ -148172,13 +153496,51 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .rc = .x87 }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, .{ ._, .f_p, .add, ._, ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .add, ._, ._, ._, ._ }, + .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -148190,7 +153552,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -148201,7 +153563,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -148221,7 +153583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -148232,7 +153594,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -148252,7 +153614,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -148263,7 +153625,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -151240,7 +156602,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -151264,7 +156626,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -151275,7 +156637,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -151297,7 +156659,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -151308,7 +156670,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -151332,7 +156694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -151341,7 +156703,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -151689,6 +157051,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, @@ -151696,8 +157059,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st6 } }, .unused, .unused, @@ -151711,14 +157074,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .rc = .x87 }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, - .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp1p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, .{ ._, .f_p, .mul, ._, ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .mul, ._, ._, ._, ._ }, + .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .avx, null, null, null }, .dst_constraints = .{ .{ .float = .xword }, .any }, @@ -151729,7 +157130,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -151740,7 +157141,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -151760,7 +157161,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -151771,7 +157172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -151791,7 +157192,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -151802,7 +157203,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, @@ -151836,7 +157237,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try res[0].finish(inst, &.{reduce.operand}, &ops, cg); }, - .reduce_optimized => |air_tag| if (use_old) try cg.airReduce(inst) else { + .reduce_optimized => |air_tag| { const inf = std.math.inf(f16); const reduce = air_datas[@intFromEnum(inst)].reduce; var ops = try cg.tempsFromOperands(inst, .{reduce.operand}); @@ -152303,7 +157704,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -152314,7 +157715,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -152336,7 +157737,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -152347,7 +157748,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -152371,7 +157772,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fminh" } }, .unused, .unused, @@ -152380,7 +157781,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -153451,7 +158852,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -153462,7 +158863,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -153482,7 +158883,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -153493,7 +158894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -153513,7 +158914,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fminq" } }, .unused, .unused, @@ -153524,7 +158925,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -153995,7 +159396,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -154006,7 +159407,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -154028,7 +159429,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -154039,7 +159440,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -154063,7 +159464,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmaxh" } }, .unused, .unused, @@ -154072,7 +159473,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -155143,7 +160544,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -155154,7 +160555,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -155174,7 +160575,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -155185,7 +160586,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -155205,7 +160606,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaxq" } }, .unused, .unused, @@ -155216,7 +160617,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -155936,7 +161337,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -155947,7 +161348,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -155969,7 +161370,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -155980,7 +161381,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -156004,7 +161405,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addhf3" } }, .unused, .unused, @@ -156013,7 +161414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -157362,6 +162763,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, @@ -157369,8 +162771,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .none, .none } }, }, .extra_temps = .{ - .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f80, .kind = .{ .reg = .st6 } }, .unused, .unused, @@ -157384,14 +162786,52 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .{ .rc = .x87 }, .unused }, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, .{ ._, .f_, .ld, .memad(.src0t, .add_unaligned_size, -16), ._, ._, ._ }, - .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .mov, .tmp1d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memi(.src0t, .tmp1), ._, ._, ._ }, .{ ._, .f_p, .add, ._, ._, ._, ._ }, - .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .add, ._, ._, ._, ._ }, + .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .avx, null, null, null }, .dst_constraints = .{ .{ .float = .xword }, .any }, @@ -157402,7 +162842,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -157413,7 +162853,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -157433,7 +162873,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -157444,7 +162884,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -157464,7 +162904,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__addtf3" } }, .unused, .unused, @@ -157475,7 +162915,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -157946,7 +163386,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -157957,7 +163397,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .vp_, .xor, .dst0x, .dst0x, .dst0x, ._ }, @@ -157979,7 +163419,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -157990,7 +163430,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, .p_, .xor, .dst0x, .dst0x, ._, ._ }, @@ -158014,7 +163454,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__mulhf3" } }, .unused, .unused, @@ -158023,7 +163463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, @@ -158905,6 +164345,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, } }, }, .{ + .required_abi = .gnu, .required_features = .{ .x87, null, null, null }, .dst_constraints = .{ .{ .float = .tbyte }, .any }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, @@ -158935,6 +164376,44 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, } }, + }, .{ + .required_abi = .msvc, + .required_features = .{ .x87, null, null, null }, + .dst_constraints = .{ .{ .float = .tbyte }, .any }, + .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .none, .none } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u16, .kind = .mem }, + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .reg = .st6 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .rc = .x87 }, .unused }, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .mem(.src0t), ._, ._, ._ }, + .{ ._, .fn_cw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .movzx, .tmp2d, .memd(.tmp1b, 1), ._, ._ }, + .{ ._, ._, .@"or", .memd(.tmp1b, 1), .ui(0b000_0_00_11), ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .mov, .memd(.tmp1b, 1), .tmp2b, ._, ._ }, + .{ ._, ._, .mov, .tmp2p, .sia(16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp2, .add_unaligned_size), ._, ._, ._ }, + .{ ._, .f_p, .mul, ._, ._, ._, ._ }, + .{ ._, ._, .add, .tmp2p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + .{ ._, .f_cw, .ld, .tmp1w, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .avx, null, null, null }, .dst_constraints = .{ .{ .float = .xword }, .any }, @@ -158945,7 +164424,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -158956,7 +164435,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -158976,7 +164455,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -158987,7 +164466,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -159007,7 +164486,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__multf3" } }, .unused, .unused, @@ -159018,7 +164497,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .reg = .xmm0 }, .unused }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, @@ -159040,7 +164519,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{reduce.operand}, &ops, cg); }, - .splat => |air_tag| if (use_old) try cg.airSplat(inst) else fallback: { + .splat => |air_tag| fallback: { const ty_op = air_datas[@intFromEnum(inst)].ty_op; if (cg.typeOf(ty_op.operand).toIntern() == .bool_type) break :fallback try cg.airSplat(inst); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); @@ -160345,16 +165824,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, } }, - }, .{ - .required_features = .{ .sse, null, null, null }, - .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .xword } }, .any }, - .src_constraints = .{ .{ .int_or_float = .xword }, .any, .any }, - .patterns = &.{ - .{ .src = .{ .mut_mem, .none, .none } }, - .{ .src = .{ .to_mut_sse, .none, .none } }, - }, - .dst_temps = .{ .{ .ref = .src0 }, .unused }, - .each = .{ .once = &.{} }, }, .{ .required_features = .{ .avx2, null, null, null }, .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .xword } }, .any }, @@ -160592,16 +166061,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, } }, - }, .{ - .required_features = .{ .@"64bit", .sse, null, null }, - .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, - .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, - .patterns = &.{ - .{ .src = .{ .mut_mem, .none, .none } }, - .{ .src = .{ .to_mut_sse, .none, .none } }, - }, - .dst_temps = .{ .{ .ref = .src0 }, .unused }, - .each = .{ .once = &.{} }, }, .{ .required_features = .{ .@"64bit", .avx2, null, null }, .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .tbyte } }, .any }, @@ -160859,11 +166318,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .memset => try cg.airMemset(inst, false), .memset_safe => try cg.airMemset(inst, true), - .memcpy, .memmove => |air_tag| if (use_old) switch (air_tag) { - else => unreachable, - .memcpy => try cg.airMemcpy(inst), - .memmove => return cg.fail("TODO implement airMemmove for {}", .{cg.target.cpu.arch}), - } else { + .memcpy, .memmove => |air_tag| { const bin_op = air_datas[@intFromEnum(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }) ++ .{undefined}; ops[2] = ops[0].getByteLen(cg) catch |err| switch (err) { @@ -160882,9 +166337,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { inline .memcpy, .memmove => |symbol| comptime &.{.{ .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr = .{ .cc = .ccc, .at = 1 } }, - .{ .to_param_gpr = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .{ .to_param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } }, } }, }, .call_frame = .{ .alignment = .@"16" }, @@ -160926,7 +166381,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .atomic_store_release => try cg.airAtomicStore(inst, .release), .atomic_store_seq_cst => try cg.airAtomicStore(inst, .seq_cst), .atomic_rmw => try cg.airAtomicRmw(inst), - .is_named_enum_value => |air_tag| if (use_old) try cg.airTagName(inst, true) else { + .is_named_enum_value => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -160934,7 +166389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"32" }, .extra_temps = .{ @@ -160960,7 +166415,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -160985,7 +166440,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"8" }, .extra_temps = .{ @@ -161017,7 +166472,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .tag_name => |air_tag| if (use_old) try cg.airTagName(inst, false) else { + .tag_name => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -161025,7 +166480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"32" }, .extra_temps = .{ @@ -161041,7 +166496,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .zigcc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -161050,7 +166505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -161066,7 +166521,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .zigcc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -161074,7 +166529,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"8" }, .extra_temps = .{ @@ -161090,7 +166545,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .at = 1 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr = .{ .cc = .zigcc, .after = 1, .at = 1 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .zigcc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, @@ -161106,7 +166561,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].toPair(&res[0], cg); try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .error_name => |air_tag| if (use_old) try cg.airErrorName(inst) else { + .error_name => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [2]Temp = undefined; @@ -161214,7 +166669,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{un_op}, &ops, cg); }, - .error_set_has_value => |air_tag| if (use_old) try cg.airErrorSetHasValue(inst) else { + .error_set_has_value => |air_tag| { const ty_op = air_datas[@intFromEnum(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}) ++ .{try cg.tempInit(ty_op.ty.toType(), .none)}; var res: [1]Temp = undefined; @@ -161222,7 +166677,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .avx, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"32" }, .extra_temps = .{ @@ -161248,7 +166703,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .required_features = .{ .sse, null, null, null }, .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -161273,7 +166728,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .{ .src_constraints = .{ .{ .int = .gpr }, .any, .any }, .patterns = &.{ - .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .at = 0 } }, .none, .none } }, + .{ .src = .{ .{ .to_param_gpr = .{ .cc = .zigcc, .after = 0, .at = 0 } }, .none, .none } }, }, .call_frame = .{ .alignment = .@"8" }, .extra_temps = .{ @@ -161306,7 +166761,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { for (ops[1..]) |op| try op.die(cg); try res[0].finish(inst, &.{ty_op.operand}, ops[0..1], cg); }, - .aggregate_init => |air_tag| if (use_old) try cg.airAggregateInit(inst) else fallback: { + .aggregate_init => |air_tag| fallback: { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const agg_ty = ty_pl.ty.toType(); if ((agg_ty.isVector(zcu) and agg_ty.childType(zcu).toIntern() == .bool_type) or @@ -161376,7 +166831,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } try res.finish(inst, &.{}, &.{}, cg); }, - .union_init => if (use_old) try cg.airUnionInit(inst) else { + .union_init => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const union_init = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; const union_ty = ty_pl.ty.toType(); @@ -161425,7 +166880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { const res = try cg.tempInit(.void, .none); try res.finish(inst, &.{prefetch.ptr}, &ops, cg); }, - .mul_add => |air_tag| if (use_old) try cg.airMulAdd(inst) else { + .mul_add => |air_tag| { const pl_op = air_datas[@intFromEnum(inst)].pl_op; const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand }); @@ -161469,7 +166924,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .scalar_float = .{ .of = .word, .is = .word } }, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } }, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -161577,7 +167036,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .to_mem, .to_mem } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, @@ -161591,14 +167050,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .mem, .unused }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp2y, .memi(.src1x, .tmp0), ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp3y, .memi(.src2x, .tmp0), ._, ._ }, .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ }, - .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_, .cvtps2ph, .memi(.dst0x, .tmp0), .tmp1y, .rm(.{}), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -161612,10 +167071,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } }, .unused, .unused, @@ -161627,15 +167086,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, - .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, - .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, - .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memi(.src0w, .tmp0), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memi(.src1w, .tmp0), .ui(0) }, + .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memi(.src2w, .tmp0), .ui(0) }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .vp_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse4_1, null, null, null }, @@ -161649,10 +167108,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } }, .unused, .unused, @@ -161664,17 +167123,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, - .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, - .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .p_w, .extr, .memi(.dst0w, .tmp0), .tmp1x, .ui(0), ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -161688,10 +167147,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .unused, @@ -161703,18 +167162,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, - .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, - .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, - .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp1x, .memi(.src0w, .tmp0), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp2x, .memi(.src1w, .tmp0), .ui(0), ._ }, + .{ ._, .p_w, .insr, .tmp3x, .memi(.src2w, .tmp0), .ui(0), ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp5w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -161728,12 +167187,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .f16, .kind = .{ .reg = .ax } }, .{ .type = .f32, .kind = .mem }, - .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f16, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmah" } }, .unused, .unused, @@ -161743,22 +167202,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .movzx, .tmp1d, .memi(.src0w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, - .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memi(.src1w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, - .{ ._, ._, .movzx, .tmp1d, .memia(.src2w, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .movzx, .tmp1d, .memi(.src2w, .tmp0), ._, ._ }, .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, .{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ }, .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, - .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .memi(.dst0w, .tmp0), .tmp1w, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .fma, null, null, null }, @@ -161818,7 +167277,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .scalar_float = .{ .of = .dword, .is = .dword } }, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } }, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -161950,7 +167413,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .to_mem, .to_mem } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, .unused, @@ -161964,13 +167427,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .mem, .unused }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, - .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_ps, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ }, + .{ ._, .v_ps, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ }, + .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ }, + .{ ._, .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -161984,10 +167447,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } }, .unused, .unused, @@ -161999,14 +167462,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, .v_ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ }, + .{ ._, .v_ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -162020,10 +167483,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f32, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaf" } }, .unused, .unused, @@ -162035,14 +167498,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ss, .mov, .tmp1x, .memi(.src0d, .tmp0), ._, ._ }, + .{ ._, ._ss, .mov, .tmp2x, .memi(.src1d, .tmp0), ._, ._ }, + .{ ._, ._ss, .mov, .tmp3x, .memi(.src2d, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ss, .mov, .memi(.dst0d, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .fma, null, null, null }, @@ -162102,7 +167565,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .scalar_float = .{ .of = .qword, .is = .qword } }, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } }, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -162234,7 +167701,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_mem, .to_mem, .to_mem } }, }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, .unused, @@ -162248,13 +167715,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{ .mem, .unused }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, - .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, + .{ .@"0:", .v_pd, .mova, .tmp1y, .memi(.src0y, .tmp0), ._, ._ }, + .{ ._, .v_pd, .mova, .tmp2y, .memi(.src1y, .tmp0), ._, ._ }, + .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memi(.src2y, .tmp0), ._ }, + .{ ._, .v_pd, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .avx, null, null, null }, @@ -162268,10 +167735,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fma" } }, .unused, .unused, @@ -162283,14 +167750,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, .v_sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ }, + .{ ._, .v_sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -162304,10 +167771,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fma" } }, .unused, .unused, @@ -162319,14 +167786,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._sd, .mov, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._sd, .mov, .tmp2x, .memi(.src1q, .tmp0), ._, ._ }, + .{ ._, ._sd, .mov, .tmp3x, .memi(.src2q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._sd, .mov, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -162340,10 +167807,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f64, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fma" } }, .unused, .unused, @@ -162355,19 +167822,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ }, - .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .movl, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .movl, .tmp1x, .memi(.src0q, .tmp0), ._, ._ }, + .{ ._, ._ps, .movl, .tmp2x, .memi(.src1q, .tmp0), ._, ._ }, + .{ ._, ._ps, .movl, .tmp3x, .memi(.src2q, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .movl, .memi(.dst0q, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -162379,7 +167847,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 3, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } }, .unused, @@ -162403,6 +167871,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, } }, }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .to_mem } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .mem(.src2), ._, ._ }, + .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .required_features = .{ .sse, .x87, null, null }, .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, @@ -162414,8 +167916,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .size = 16 * 3, .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f80, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .{ .type = .f80, .kind = .{ .frame = .call_frame } }, .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } }, .unused, @@ -162429,18 +167931,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .mova, .tmp1x, .memi(.src1x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, - .{ ._, ._ps, .mova, .tmp1x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._ps, .mova, .tmp1x, .memi(.src2x, .tmp0), ._, ._ }, .{ ._, ._ps, .mova, .memd(.tmp2x, 16 * 2), .tmp1x, ._, ._ }, .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, - .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .f_p, .st, .memi(.dst0t, .tmp0), ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .src_constraints = .{ + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .to_mem } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__fmax" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memi(.dst0, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memi(.src0, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp3p, .memi(.src1, .tmp0), ._, ._ }, + .{ ._, ._, .lea, .tmp4p, .memi(.src2, .tmp0), ._, ._ }, + .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -162450,7 +167988,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .scalar_float = .{ .of = .xword, .is = .xword } }, }, .patterns = &.{ - .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, + .{ .src = .{ + .{ .to_param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } }, + .{ .to_param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } }, + } }, }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ @@ -162483,10 +168025,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } }, .unused, .unused, @@ -162498,14 +168040,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", .v_dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ }, + .{ ._, .v_dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse2, null, null, null }, @@ -162519,10 +168061,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } }, .unused, .unused, @@ -162534,14 +168076,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, + .{ .@"0:", ._dqa, .mov, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp2x, .memi(.src1x, .tmp0), ._, ._ }, + .{ ._, ._dqa, .mov, .tmp3x, .memi(.src2x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, }, .{ .required_features = .{ .sse, null, null, null }, @@ -162555,10 +168097,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, - .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, + .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .f128, .kind = .{ .param_sse = .{ .cc = .ccc, .after = 2, .at = 2 } } }, .{ .type = .usize, .kind = .{ .extern_func = "fmaq" } }, .unused, .unused, @@ -162570,14 +168112,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .dst_temps = .{ .mem, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ - .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, - .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, - .{ ._, ._ps, .mova, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._ps, .mova, .tmp1x, .memi(.src0x, .tmp0), ._, ._ }, + .{ ._, ._ps, .mova, .tmp2x, .memi(.src1x, .tmp0), ._, ._ }, + .{ ._, ._ps, .mova, .tmp3x, .memi(.src2x, .tmp0), ._, ._ }, .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, - .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, - .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, - .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + .{ ._, ._ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, + .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, + .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {} {}", .{ @@ -162591,7 +168133,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }; try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_op.operand }, &ops, cg); }, - .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { + .field_parent_ptr => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr}); @@ -162603,7 +168145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{field_parent_ptr.field_ptr}, &ops, cg); }, .wasm_memory_size, .wasm_memory_grow => unreachable, - .cmp_lt_errors_len => |air_tag| if (use_old) try cg.airCmpLtErrorsLen(inst) else { + .cmp_lt_errors_len => |air_tag| { const un_op = air_datas[@intFromEnum(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; @@ -163494,36 +169036,38 @@ fn getValueIfFree(self: *CodeGen, value: MCValue, inst: ?Air.Inst.Index) void { self.register_manager.getRegAssumeFree(reg, inst); } -fn freeReg(self: *CodeGen, reg: Register) !void { +const FreeOptions = struct { emit_instructions: bool = true }; + +fn freeReg(self: *CodeGen, reg: Register, comptime opts: FreeOptions) !void { self.register_manager.freeReg(reg); - if (reg.isClass(.x87)) try self.asmRegister(.{ .f_, .free }, reg); + if (opts.emit_instructions and reg.isClass(.x87)) try self.asmRegister(.{ .f_, .free }, reg); } -fn freeValue(self: *CodeGen, value: MCValue) !void { +fn freeValue(self: *CodeGen, value: MCValue, comptime opts: FreeOptions) !void { switch (value) { - .register => |reg| try self.freeReg(reg), + .register => |reg| try self.freeReg(reg, opts), inline .register_pair, .register_triple, .register_quadruple, - => |regs| for (regs) |reg| try self.freeReg(reg), - .register_offset, .indirect => |reg_off| try self.freeReg(reg_off.reg), + => |regs| for (regs) |reg| try self.freeReg(reg, opts), + .register_offset, .indirect => |reg_off| try self.freeReg(reg_off.reg, opts), .register_overflow => |reg_ov| { - try self.freeReg(reg_ov.reg); + try self.freeReg(reg_ov.reg, opts); self.eflags_inst = null; }, - .register_mask => |reg_mask| try self.freeReg(reg_mask.reg), + .register_mask => |reg_mask| try self.freeReg(reg_mask.reg, opts), .eflags => self.eflags_inst = null, else => {}, // TODO process stack allocation death } } fn feed(self: *CodeGen, bt: *Air.Liveness.BigTomb, operand: Air.Inst.Ref) !void { - if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst); + if (bt.feed()) if (operand.toIndex()) |inst| try self.processDeath(inst, .{}); } /// Asserts there is already capacity to insert into top branch inst_table. -fn processDeath(self: *CodeGen, inst: Air.Inst.Index) !void { - try self.inst_tracking.getPtr(inst).?.die(self, inst); +fn processDeath(self: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions) !void { + try self.inst_tracking.getPtr(inst).?.die(self, inst, opts); } fn finishAirResult(self: *CodeGen, inst: Air.Inst.Index, result: MCValue) void { @@ -163550,7 +169094,7 @@ fn finishAir( for (0.., operands) |op_index, op| { if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; if (self.reused_operands.isSet(op_index)) continue; - try self.processDeath(op.toIndexAllowNone() orelse continue); + try self.processDeath(op.toIndexAllowNone() orelse continue, .{}); } self.finishAirResult(inst, result); } @@ -163772,21 +169316,6 @@ fn vectorSize(cg: *CodeGen, kind: enum { int, float }) u6 { })) 32 else if (cg.hasFeature(.sse)) 16 else 8; } -fn limbType(cg: *CodeGen, ty: Type) Type { - const pt = cg.pt; - const zcu = pt.zcu; - const vector_size = cg.vectorSize(if (ty.isRuntimeFloat()) .float else .int); - const scalar_ty, const scalar_size = scalar: { - const scalar_ty = ty.scalarType(zcu); - const scalar_size = scalar_ty.abiSize(zcu); - if (scalar_size <= vector_size) break :scalar .{ scalar_ty, scalar_size }; - }; - pt.vectorType(.{ - .len = @divExact(vector_size, scalar_size), - .child = scalar_ty.toIntern(), - }); -} - const State = struct { registers: RegisterManager.TrackedRegisters, reg_tracking: [RegisterManager.RegisterBitSet.bit_length]InstTracking, @@ -163835,12 +169364,12 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co for ( self.inst_tracking.keys()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)], self.inst_tracking.values()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)], - ) |inst, *tracking| try tracking.die(self, inst); + ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions }); self.next_temp_index = state.next_temp_index; for ( self.inst_tracking.keys()[state.inst_tracking_len..], self.inst_tracking.values()[state.inst_tracking_len..], - ) |inst, *tracking| try tracking.die(self, inst); + ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions }); self.inst_tracking.shrinkRetainingCapacity(state.inst_tracking_len); } @@ -163854,7 +169383,7 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co self.inst_tracking.values()[Temp.Index.max..state.inst_tracking_len], ) |inst, *tracking| try tracking.resurrect(self, inst, state.scope_generation); } - for (deaths) |death| try self.processDeath(death); + for (deaths) |death| try self.processDeath(death, .{ .emit_instructions = opts.emit_instructions }); const ExpectedContents = [@typeInfo(RegisterManager.TrackedRegisters).array.len]RegisterLock; var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) = @@ -169028,6 +174557,7 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE .register_quadruple, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, => unreachable, // not a valid pointer @@ -169248,6 +174778,7 @@ fn store( .register_quadruple, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, => unreachable, // not a valid pointer @@ -169307,31 +174838,6 @@ fn airStore(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { return self.finishAir(inst, .none, .{ bin_op.lhs, bin_op.rhs, .none }); } -fn airStructFieldPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const extra = self.air.extraData(Air.StructField, ty_pl.payload).data; - const result = try self.fieldPtr(inst, extra.struct_operand, extra.field_index); - return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none }); -} - -fn airStructFieldPtrIndex(self: *CodeGen, inst: Air.Inst.Index, field_index: u8) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; - const result = try self.fieldPtr(inst, ty_op.operand, field_index); - return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); -} - -fn fieldPtr(self: *CodeGen, inst: Air.Inst.Index, operand: Air.Inst.Ref, field_index: u32) !MCValue { - const ptr_field_ty = self.typeOfIndex(inst); - - const src_mcv = try self.resolveInst(operand); - const dst_mcv = if (switch (src_mcv) { - .immediate, .lea_frame => true, - .register, .register_offset => self.reuseOperand(inst, operand, 0, src_mcv), - else => false, - }) src_mcv else try self.copyToRegisterWithInstTracking(inst, ptr_field_ty, src_mcv); - return dst_mcv.offset(self.fieldOffset(self.typeOf(operand), ptr_field_ty, field_index)); -} - fn fieldOffset(self: *CodeGen, ptr_agg_ty: Type, ptr_field_ty: Type, field_index: u32) i32 { const pt = self.pt; const zcu = pt.zcu; @@ -169344,291 +174850,6 @@ fn fieldOffset(self: *CodeGen, ptr_agg_ty: Type, ptr_field_ty: Type, field_index }; } -fn airStructFieldVal(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const extra = self.air.extraData(Air.StructField, ty_pl.payload).data; - const result: MCValue = result: { - const operand = extra.struct_operand; - const index = extra.field_index; - - const container_ty = self.typeOf(operand); - const container_rc = self.regSetForType(container_ty); - const field_ty = container_ty.fieldType(index, zcu); - if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) break :result .none; - const field_rc = self.regSetForType(field_ty); - const field_is_gp = field_rc.supersetOf(abi.RegisterClass.gp); - - const src_mcv = try self.resolveInst(operand); - const field_off: u32 = switch (container_ty.containerLayout(zcu)) { - .auto, .@"extern" => @intCast(container_ty.structFieldOffset(extra.field_index, zcu) * 8), - .@"packed" => if (zcu.typeToStruct(container_ty)) |loaded_struct| - pt.structPackedFieldBitOffset(loaded_struct, extra.field_index) - else - 0, - }; - - switch (src_mcv) { - .register => |src_reg| { - const src_reg_lock = self.register_manager.lockRegAssumeUnused(src_reg); - defer self.register_manager.unlockReg(src_reg_lock); - - const src_in_field_rc = - field_rc.isSet(RegisterManager.indexOfRegIntoTracked(src_reg).?); - const dst_reg = if (src_in_field_rc and self.reuseOperand(inst, operand, 0, src_mcv)) - src_reg - else if (field_off == 0) - (try self.copyToRegisterWithInstTracking(inst, field_ty, src_mcv)).register - else - try self.copyToTmpRegister(.usize, .{ .register = src_reg }); - const dst_mcv: MCValue = .{ .register = dst_reg }; - const dst_lock = self.register_manager.lockReg(dst_reg); - defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); - - if (field_off > 0) { - try self.spillEflagsIfOccupied(); - try self.genShiftBinOpMir(.{ ._r, .sh }, .usize, dst_mcv, .u8, .{ .immediate = field_off }); - } - if (abi.RegisterClass.gp.isSet(RegisterManager.indexOfRegIntoTracked(dst_reg).?) and - container_ty.abiSize(zcu) * 8 > field_ty.bitSize(zcu)) - try self.truncateRegister(field_ty, dst_reg); - - break :result if (field_off == 0 or field_rc.supersetOf(abi.RegisterClass.gp)) - dst_mcv - else - try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv); - }, - .register_pair => |src_regs| { - const src_regs_lock = self.register_manager.lockRegsAssumeUnused(2, src_regs); - defer for (src_regs_lock) |lock| self.register_manager.unlockReg(lock); - - const field_bit_size: u32 = @intCast(field_ty.bitSize(zcu)); - const src_reg = if (field_off + field_bit_size <= 64) - src_regs[0] - else if (field_off >= 64) - src_regs[1] - else { - const dst_regs: [2]Register = if (field_rc.supersetOf(container_rc) and - self.reuseOperand(inst, operand, 0, src_mcv)) src_regs else dst: { - const dst_regs = - try self.register_manager.allocRegs(2, @splat(null), field_rc); - const dst_locks = self.register_manager.lockRegsAssumeUnused(2, dst_regs); - defer for (dst_locks) |lock| self.register_manager.unlockReg(lock); - - try self.genCopy(container_ty, .{ .register_pair = dst_regs }, src_mcv, .{}); - break :dst dst_regs; - }; - const dst_mcv = MCValue{ .register_pair = dst_regs }; - const dst_locks = self.register_manager.lockRegs(2, dst_regs); - defer for (dst_locks) |dst_lock| if (dst_lock) |lock| - self.register_manager.unlockReg(lock); - - if (field_off > 0) { - try self.spillEflagsIfOccupied(); - try self.genShiftBinOpMir(.{ ._r, .sh }, .u128, dst_mcv, .u8, .{ .immediate = field_off }); - } - - if (field_bit_size <= 64) { - if (self.regExtraBits(field_ty) > 0) - try self.truncateRegister(field_ty, dst_regs[0]); - break :result if (field_rc.supersetOf(abi.RegisterClass.gp)) - .{ .register = dst_regs[0] } - else - try self.copyToRegisterWithInstTracking(inst, field_ty, .{ - .register = dst_regs[0], - }); - } - - if (field_bit_size < 128) try self.truncateRegister( - try pt.intType(.unsigned, @intCast(field_bit_size - 64)), - dst_regs[1], - ); - break :result if (field_rc.supersetOf(abi.RegisterClass.gp)) - dst_mcv - else - try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv); - }; - - const dst_reg = try self.copyToTmpRegister(.usize, .{ .register = src_reg }); - const dst_mcv = MCValue{ .register = dst_reg }; - const dst_lock = self.register_manager.lockReg(dst_reg); - defer if (dst_lock) |lock| self.register_manager.unlockReg(lock); - - if (field_off % 64 > 0) { - try self.spillEflagsIfOccupied(); - try self.genShiftBinOpMir(.{ ._r, .sh }, .usize, dst_mcv, .u8, .{ .immediate = field_off % 64 }); - } - if (self.regExtraBits(field_ty) > 0) try self.truncateRegister(field_ty, dst_reg); - - break :result if (field_rc.supersetOf(abi.RegisterClass.gp)) - dst_mcv - else - try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv); - }, - .register_overflow => |ro| { - switch (index) { - // Get wrapped value for overflow operation. - 0 => if (self.reuseOperand(inst, extra.struct_operand, 0, src_mcv)) { - self.eflags_inst = null; // actually stop tracking the overflow part - break :result .{ .register = ro.reg }; - } else break :result try self.copyToRegisterWithInstTracking(inst, .usize, .{ .register = ro.reg }), - // Get overflow bit. - 1 => if (self.reuseOperandAdvanced(inst, extra.struct_operand, 0, src_mcv, null)) { - self.eflags_inst = inst; // actually keep tracking the overflow part - break :result .{ .eflags = ro.eflags }; - } else { - const dst_reg = try self.register_manager.allocReg(inst, abi.RegisterClass.gp); - try self.asmSetccRegister(ro.eflags, dst_reg.to8()); - break :result .{ .register = dst_reg.to8() }; - }, - else => unreachable, - } - }, - .load_frame => |frame_addr| { - const field_abi_size: u32 = @intCast(field_ty.abiSize(zcu)); - if (field_off % 8 == 0) { - const field_byte_off = @divExact(field_off, 8); - const off_mcv = src_mcv.address().offset(@intCast(field_byte_off)).deref(); - const field_bit_size = field_ty.bitSize(zcu); - - if (field_abi_size <= 8) { - const int_ty = try pt.intType( - if (field_ty.isAbiInt(zcu)) field_ty.intInfo(zcu).signedness else .unsigned, - @intCast(field_bit_size), - ); - - const dst_reg = try self.register_manager.allocReg( - if (field_is_gp) inst else null, - abi.RegisterClass.gp, - ); - const dst_mcv = MCValue{ .register = dst_reg }; - const dst_lock = self.register_manager.lockRegAssumeUnused(dst_reg); - defer self.register_manager.unlockReg(dst_lock); - - try self.genCopy(int_ty, dst_mcv, off_mcv, .{}); - if (self.regExtraBits(field_ty) > 0) try self.truncateRegister(int_ty, dst_reg); - break :result if (field_is_gp) - dst_mcv - else - try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv); - } - - const container_abi_size: u32 = @intCast(container_ty.abiSize(zcu)); - const dst_mcv = if (field_byte_off + field_abi_size <= container_abi_size and - self.reuseOperand(inst, operand, 0, src_mcv)) - off_mcv - else dst: { - const dst_mcv = try self.allocRegOrMem(inst, true); - try self.genCopy(field_ty, dst_mcv, off_mcv, .{}); - break :dst dst_mcv; - }; - if (field_abi_size * 8 > field_bit_size and dst_mcv.isBase()) { - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - const hi_mcv = - dst_mcv.address().offset(@intCast(field_bit_size / 64 * 8)).deref(); - try self.genSetReg(tmp_reg, .usize, hi_mcv, .{}); - try self.truncateRegister(field_ty, tmp_reg); - try self.genCopy(.usize, hi_mcv, .{ .register = tmp_reg }, .{}); - } - break :result dst_mcv; - } - - const limb_abi_size: u31 = @min(field_abi_size, 8); - const limb_abi_bits = limb_abi_size * 8; - const field_byte_off: i32 = @intCast(field_off / limb_abi_bits * limb_abi_size); - const field_bit_off = field_off % limb_abi_bits; - - if (field_abi_size > 8) { - return self.fail("TODO implement struct_field_val with large packed field", .{}); - } - - const dst_reg = try self.register_manager.allocReg( - if (field_is_gp) inst else null, - abi.RegisterClass.gp, - ); - const field_extra_bits = self.regExtraBits(field_ty); - const load_abi_size = - if (field_bit_off < field_extra_bits) field_abi_size else field_abi_size * 2; - if (load_abi_size <= 8) { - const load_reg = registerAlias(dst_reg, load_abi_size); - try self.asmRegisterMemory(.{ ._, .mov }, load_reg, .{ - .base = .{ .frame = frame_addr.index }, - .mod = .{ .rm = .{ - .size = .fromSize(load_abi_size), - .disp = frame_addr.off + field_byte_off, - } }, - }); - try self.spillEflagsIfOccupied(); - try self.asmRegisterImmediate(.{ ._r, .sh }, load_reg, .u(field_bit_off)); - } else { - const tmp_reg = registerAlias( - try self.register_manager.allocReg(null, abi.RegisterClass.gp), - field_abi_size, - ); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - const dst_alias = registerAlias(dst_reg, field_abi_size); - try self.asmRegisterMemory( - .{ ._, .mov }, - dst_alias, - .{ - .base = .{ .frame = frame_addr.index }, - .mod = .{ .rm = .{ - .size = .fromSize(field_abi_size), - .disp = frame_addr.off + field_byte_off, - } }, - }, - ); - try self.asmRegisterMemory(.{ ._, .mov }, tmp_reg, .{ - .base = .{ .frame = frame_addr.index }, - .mod = .{ .rm = .{ - .size = .fromSize(field_abi_size), - .disp = frame_addr.off + field_byte_off + limb_abi_size, - } }, - }); - try self.spillEflagsIfOccupied(); - try self.asmRegisterRegisterImmediate( - .{ ._rd, .sh }, - dst_alias, - tmp_reg, - .u(field_bit_off), - ); - } - - if (field_extra_bits > 0) try self.truncateRegister(field_ty, dst_reg); - - const dst_mcv = MCValue{ .register = dst_reg }; - break :result if (field_is_gp) - dst_mcv - else - try self.copyToRegisterWithInstTracking(inst, field_ty, dst_mcv); - }, - else => return self.fail("TODO implement airStructFieldVal for {}", .{src_mcv}), - } - }; - return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none }); -} - -fn airFieldParentPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; - - const ptr_agg_ty = self.typeOfIndex(inst); - const src_mcv = try self.resolveInst(extra.field_ptr); - const dst_mcv = if (src_mcv.isRegisterOffset() and - self.reuseOperand(inst, extra.field_ptr, 0, src_mcv)) - src_mcv - else - try self.copyToRegisterWithInstTracking(inst, ptr_agg_ty, src_mcv); - const result = dst_mcv.offset(-self.fieldOffset(ptr_agg_ty, self.typeOf(extra.field_ptr), extra.field_index)); - return self.finishAir(inst, result, .{ extra.field_ptr, .none, .none }); -} - fn genUnOp(self: *CodeGen, maybe_inst: ?Air.Inst.Index, tag: Air.Inst.Tag, src_air: Air.Inst.Ref) !MCValue { const pt = self.pt; const zcu = pt.zcu; @@ -169732,6 +174953,7 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: .eflags, .register_overflow, .register_mask, + .indirect_load_frame, .lea_frame, .lea_nav, .lea_uav, @@ -170401,495 +175623,6 @@ fn genShiftBinOpMir( }); } -/// Result is always a register. -/// Clobbers .rcx for non-immediate rhs, therefore care is needed to spill .rcx upfront. -/// Asserts .rcx is free. -fn genShiftBinOp( - self: *CodeGen, - air_tag: Air.Inst.Tag, - maybe_inst: ?Air.Inst.Index, - lhs_mcv: MCValue, - rhs_mcv: MCValue, - lhs_ty: Type, - rhs_ty: Type, -) !MCValue { - const pt = self.pt; - const zcu = pt.zcu; - if (lhs_ty.zigTypeTag(zcu) == .vector) return self.fail("TODO implement genShiftBinOp for {}", .{ - lhs_ty.fmt(pt), - }); - - try self.register_manager.getKnownReg(.rcx, null); - const rcx_lock = self.register_manager.lockReg(.rcx); - defer if (rcx_lock) |lock| self.register_manager.unlockReg(lock); - - const mat_lhs_mcv: MCValue, const can_reuse_lhs = switch (lhs_mcv) { - .register => |lhs_reg| switch (lhs_reg.class()) { - .general_purpose => .{ lhs_mcv, true }, - else => lhs: { - const mat_lhs_mcv = try self.allocTempRegOrMem(lhs_ty, true); - try self.genCopy(lhs_ty, mat_lhs_mcv, lhs_mcv, .{}); - break :lhs .{ mat_lhs_mcv, false }; - }, - }, - else => .{ lhs_mcv, true }, - }; - const lhs_lock = switch (mat_lhs_mcv) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock); - - const rhs_lock = switch (rhs_mcv) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); - - const dst_mcv: MCValue = dst: { - if (can_reuse_lhs) if (maybe_inst) |inst| { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; - if (self.reuseOperand(inst, bin_op.lhs, 0, mat_lhs_mcv)) break :dst mat_lhs_mcv; - }; - const dst_mcv = try self.allocRegOrMemAdvanced(lhs_ty, maybe_inst, true); - try self.genCopy(lhs_ty, dst_mcv, mat_lhs_mcv, .{}); - break :dst dst_mcv; - }; - - const signedness = lhs_ty.intInfo(zcu).signedness; - try self.genShiftBinOpMir(switch (air_tag) { - .shl, .shl_exact => switch (signedness) { - .signed => .{ ._l, .sa }, - .unsigned => .{ ._l, .sh }, - }, - .shr, .shr_exact => switch (signedness) { - .signed => .{ ._r, .sa }, - .unsigned => .{ ._r, .sh }, - }, - else => unreachable, - }, lhs_ty, dst_mcv, rhs_ty, rhs_mcv); - return dst_mcv; -} - -/// Result is always a register. -/// Clobbers .rax and .rdx therefore care is needed to spill .rax and .rdx upfront. -/// Asserts .rax and .rdx are free. -fn genMulDivBinOp( - self: *CodeGen, - tag: Air.Inst.Tag, - maybe_inst: ?Air.Inst.Index, - dst_ty: Type, - src_ty: Type, - lhs_mcv: MCValue, - rhs_mcv: MCValue, -) !MCValue { - const pt = self.pt; - const zcu = pt.zcu; - if (dst_ty.zigTypeTag(zcu) == .vector or dst_ty.zigTypeTag(zcu) == .float) return self.fail( - "TODO implement genMulDivBinOp for {s} from {} to {}", - .{ @tagName(tag), src_ty.fmt(pt), dst_ty.fmt(pt) }, - ); - const dst_abi_size: u32 = @intCast(dst_ty.abiSize(zcu)); - const src_abi_size: u32 = @intCast(src_ty.abiSize(zcu)); - - assert(self.register_manager.isRegFree(.rax)); - assert(self.register_manager.isRegFree(.rcx)); - assert(self.register_manager.isRegFree(.rdx)); - assert(self.eflags_inst == null); - - if (dst_abi_size == 16 and src_abi_size == 16) { - assert(tag == .mul or tag == .mul_wrap); - const reg_locks = self.register_manager.lockRegs(2, .{ .rax, .rdx }); - defer for (reg_locks) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock); - - const mat_lhs_mcv = switch (lhs_mcv) { - .load_nav, .load_uav, .load_lazy_sym => mat_lhs_mcv: { - // TODO clean this up! - const addr_reg = try self.copyToTmpRegister(.usize, lhs_mcv.address()); - break :mat_lhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; - }, - else => lhs_mcv, - }; - const mat_lhs_lock = switch (mat_lhs_mcv) { - .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg), - else => null, - }; - defer if (mat_lhs_lock) |lock| self.register_manager.unlockReg(lock); - const mat_rhs_mcv = switch (rhs_mcv) { - .load_nav, .load_uav, .load_lazy_sym => mat_rhs_mcv: { - // TODO clean this up! - const addr_reg = try self.copyToTmpRegister(.usize, rhs_mcv.address()); - break :mat_rhs_mcv MCValue{ .indirect = .{ .reg = addr_reg } }; - }, - else => rhs_mcv, - }; - const mat_rhs_lock = switch (mat_rhs_mcv) { - .indirect => |reg_off| self.register_manager.lockReg(reg_off.reg), - else => null, - }; - defer if (mat_rhs_lock) |lock| self.register_manager.unlockReg(lock); - - const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - if (mat_lhs_mcv.isBase()) - try self.asmRegisterMemory(.{ ._, .mov }, .rax, try mat_lhs_mcv.mem(self, .{ .size = .qword })) - else - try self.asmRegisterRegister(.{ ._, .mov }, .rax, mat_lhs_mcv.register_pair[0]); - if (mat_rhs_mcv.isBase()) try self.asmRegisterMemory( - .{ ._, .mov }, - tmp_reg, - try mat_rhs_mcv.address().offset(8).deref().mem(self, .{ .size = .qword }), - ) else try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, mat_rhs_mcv.register_pair[1]); - try self.asmRegisterRegister(.{ .i_, .mul }, tmp_reg, .rax); - if (mat_rhs_mcv.isBase()) - try self.asmMemory(.{ ._, .mul }, try mat_rhs_mcv.mem(self, .{ .size = .qword })) - else - try self.asmRegister(.{ ._, .mul }, mat_rhs_mcv.register_pair[0]); - try self.asmRegisterRegister(.{ ._, .add }, .rdx, tmp_reg); - if (mat_lhs_mcv.isBase()) try self.asmRegisterMemory( - .{ ._, .mov }, - tmp_reg, - try mat_lhs_mcv.address().offset(8).deref().mem(self, .{ .size = .qword }), - ) else try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg, mat_lhs_mcv.register_pair[1]); - if (mat_rhs_mcv.isBase()) - try self.asmRegisterMemory(.{ .i_, .mul }, tmp_reg, try mat_rhs_mcv.mem(self, .{ .size = .qword })) - else - try self.asmRegisterRegister(.{ .i_, .mul }, tmp_reg, mat_rhs_mcv.register_pair[0]); - try self.asmRegisterRegister(.{ ._, .add }, .rdx, tmp_reg); - return .{ .register_pair = .{ .rax, .rdx } }; - } - - if (switch (tag) { - else => unreachable, - .mul, .mul_wrap => dst_abi_size != src_abi_size and dst_abi_size != src_abi_size * 2, - .div_trunc, .div_floor, .div_exact, .rem, .mod => dst_abi_size != src_abi_size, - } or src_abi_size > 8) { - const src_info = src_ty.intInfo(zcu); - switch (tag) { - .mul, .mul_wrap => { - const slow_inc = self.hasFeature(.slow_incdec); - const limb_len = std.math.divCeil(u32, src_abi_size, 8) catch unreachable; - - try self.spillRegisters(&.{ .rax, .rcx, .rdx }); - const reg_locks = self.register_manager.lockRegs(3, .{ .rax, .rcx, .rdx }); - defer for (reg_locks) |reg_lock| if (reg_lock) |lock| - self.register_manager.unlockReg(lock); - - const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false); - try self.genInlineMemset( - dst_mcv.address(), - .{ .immediate = 0 }, - .{ .immediate = src_abi_size }, - .{}, - ); - - const temp_regs = - try self.register_manager.allocRegs(4, @splat(null), abi.RegisterClass.gp); - const temp_locks = self.register_manager.lockRegsAssumeUnused(4, temp_regs); - defer for (temp_locks) |lock| self.register_manager.unlockReg(lock); - - try self.asmRegisterRegister(.{ ._, .xor }, temp_regs[0].to32(), temp_regs[0].to32()); - - const outer_loop: Mir.Inst.Index = @intCast(self.mir_instructions.len); - try self.asmRegisterMemory(.{ ._, .mov }, temp_regs[1].to64(), .{ - .base = .{ .frame = rhs_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .index = temp_regs[0].to64(), - .scale = .@"8", - .disp = rhs_mcv.load_frame.off, - } }, - }); - try self.asmRegisterRegister(.{ ._, .@"test" }, temp_regs[1].to64(), temp_regs[1].to64()); - const skip_inner = try self.asmJccReloc(.z, undefined); - - try self.asmRegisterRegister(.{ ._, .xor }, temp_regs[2].to32(), temp_regs[2].to32()); - try self.asmRegisterRegister(.{ ._, .mov }, temp_regs[3].to32(), temp_regs[0].to32()); - try self.asmRegisterRegister(.{ ._, .xor }, .ecx, .ecx); - try self.asmRegisterRegister(.{ ._, .xor }, .edx, .edx); - - const inner_loop: Mir.Inst.Index = @intCast(self.mir_instructions.len); - try self.asmRegisterImmediate(.{ ._r, .sh }, .cl, .u(1)); - try self.asmMemoryRegister(.{ ._, .adc }, .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .index = temp_regs[3].to64(), - .scale = .@"8", - .disp = dst_mcv.load_frame.off, - } }, - }, .rdx); - try self.asmSetccRegister(.c, .cl); - - try self.asmRegisterMemory(.{ ._, .mov }, .rax, .{ - .base = .{ .frame = lhs_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .index = temp_regs[2].to64(), - .scale = .@"8", - .disp = lhs_mcv.load_frame.off, - } }, - }); - try self.asmRegister(.{ ._, .mul }, temp_regs[1].to64()); - - try self.asmRegisterImmediate(.{ ._r, .sh }, .ch, .u(1)); - try self.asmMemoryRegister(.{ ._, .adc }, .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .index = temp_regs[3].to64(), - .scale = .@"8", - .disp = dst_mcv.load_frame.off, - } }, - }, .rax); - try self.asmSetccRegister(.c, .ch); - - if (slow_inc) { - try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[2].to32(), .u(1)); - try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[3].to32(), .u(1)); - } else { - try self.asmRegister(.{ ._c, .in }, temp_regs[2].to32()); - try self.asmRegister(.{ ._c, .in }, temp_regs[3].to32()); - } - try self.asmRegisterImmediate(.{ ._, .cmp }, temp_regs[3].to32(), .u(limb_len)); - _ = try self.asmJccReloc(.b, inner_loop); - - self.performReloc(skip_inner); - if (slow_inc) { - try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), .u(1)); - } else { - try self.asmRegister(.{ ._c, .in }, temp_regs[0].to32()); - } - try self.asmRegisterImmediate(.{ ._, .cmp }, temp_regs[0].to32(), .u(limb_len)); - _ = try self.asmJccReloc(.b, outer_loop); - - return dst_mcv; - }, - .div_trunc, .div_floor, .div_exact, .rem, .mod => switch (src_info.signedness) { - .signed => {}, - .unsigned => { - const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false); - const manyptr_u32_ty = try pt.ptrType(.{ - .child = .u32_type, - .flags = .{ - .size = .many, - }, - }); - const manyptr_const_u32_ty = try pt.ptrType(.{ - .child = .u32_type, - .flags = .{ - .size = .many, - .is_const = true, - }, - }); - _ = try self.genCall(.{ .extern_func = .{ - .return_type = .void_type, - .param_types = &.{ - manyptr_u32_ty.toIntern(), - manyptr_const_u32_ty.toIntern(), - manyptr_const_u32_ty.toIntern(), - .usize_type, - }, - .sym = switch (tag) { - .div_trunc, - .div_floor, - .div_exact, - => "__udivei4", - .rem, - .mod, - => "__umodei4", - else => unreachable, - }, - } }, &.{ - manyptr_u32_ty, - manyptr_const_u32_ty, - manyptr_const_u32_ty, - .usize, - }, &.{ - dst_mcv.address(), - lhs_mcv.address(), - rhs_mcv.address(), - .{ .immediate = 8 * src_abi_size }, - }, .{}); - return dst_mcv; - }, - }, - else => {}, - } - return self.fail( - "TODO implement genMulDivBinOp for {s} from {} to {}", - .{ @tagName(tag), src_ty.fmt(pt), dst_ty.fmt(pt) }, - ); - } - const ty = if (dst_abi_size <= 8) dst_ty else src_ty; - const abi_size = if (dst_abi_size <= 8) dst_abi_size else src_abi_size; - - const reg_locks = self.register_manager.lockRegs(2, .{ .rax, .rdx }); - defer for (reg_locks) |reg_lock| if (reg_lock) |lock| self.register_manager.unlockReg(lock); - - const int_info = ty.intInfo(zcu); - const signedness = int_info.signedness; - switch (tag) { - .mul, - .mul_wrap, - .rem, - .div_trunc, - .div_exact, - => { - const track_inst_rax = switch (tag) { - .mul, .mul_wrap => if (dst_abi_size <= 8) maybe_inst else null, - .div_exact, .div_trunc => maybe_inst, - else => null, - }; - const track_inst_rdx = switch (tag) { - .rem => maybe_inst, - else => null, - }; - try self.register_manager.getKnownReg(.rax, track_inst_rax); - try self.register_manager.getKnownReg(.rdx, track_inst_rdx); - - try self.genIntMulDivOpMir(switch (signedness) { - .signed => switch (tag) { - .mul, .mul_wrap => .{ .i_, .mul }, - .div_trunc, .div_exact, .rem => .{ .i_, .div }, - else => unreachable, - }, - .unsigned => switch (tag) { - .mul, .mul_wrap => .{ ._, .mul }, - .div_trunc, .div_exact, .rem => .{ ._, .div }, - else => unreachable, - }, - }, ty, lhs_mcv, rhs_mcv); - - switch (tag) { - .mul, .rem, .div_trunc, .div_exact => {}, - .mul_wrap => if (dst_ty.intInfo(zcu).bits < 8 * dst_abi_size) try self.truncateRegister( - dst_ty, - if (dst_abi_size <= 8) .rax else .rdx, - ), - else => unreachable, - } - - if (dst_abi_size <= 8) return .{ .register = registerAlias(switch (tag) { - .mul, .mul_wrap, .div_trunc, .div_exact => .rax, - .rem => .rdx, - else => unreachable, - }, dst_abi_size) }; - - const dst_mcv = try self.allocRegOrMemAdvanced(dst_ty, maybe_inst, false); - try self.asmMemoryRegister(.{ ._, .mov }, .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .disp = dst_mcv.load_frame.off, - } }, - }, .rax); - try self.asmMemoryRegister(.{ ._, .mov }, .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .disp = dst_mcv.load_frame.off + 8, - } }, - }, .rdx); - return dst_mcv; - }, - - .mod => { - try self.register_manager.getKnownReg(.rax, null); - try self.register_manager.getKnownReg( - .rdx, - if (signedness == .unsigned) maybe_inst else null, - ); - - switch (signedness) { - .signed => { - const lhs_lock = switch (lhs_mcv) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock); - const rhs_lock = switch (rhs_mcv) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); - - // hack around hazard between rhs and div_floor by copying rhs to another register - const rhs_copy = try self.copyToTmpRegister(ty, rhs_mcv); - const rhs_copy_lock = self.register_manager.lockRegAssumeUnused(rhs_copy); - defer self.register_manager.unlockReg(rhs_copy_lock); - - const div_floor = try self.genInlineIntDivFloor(ty, lhs_mcv, rhs_mcv); - try self.genIntMulComplexOpMir(ty, div_floor, .{ .register = rhs_copy }); - const div_floor_lock = self.register_manager.lockReg(div_floor.register); - defer if (div_floor_lock) |lock| self.register_manager.unlockReg(lock); - - const result: MCValue = if (maybe_inst) |inst| - try self.copyToRegisterWithInstTracking(inst, ty, lhs_mcv) - else - .{ .register = try self.copyToTmpRegister(ty, lhs_mcv) }; - try self.genBinOpMir(.{ ._, .sub }, ty, result, div_floor); - - return result; - }, - .unsigned => { - try self.genIntMulDivOpMir(.{ ._, .div }, ty, lhs_mcv, rhs_mcv); - return .{ .register = registerAlias(.rdx, abi_size) }; - }, - } - }, - - .div_floor => { - try self.register_manager.getKnownReg( - .rax, - if (signedness == .unsigned) maybe_inst else null, - ); - try self.register_manager.getKnownReg(.rdx, null); - - const lhs_lock: ?RegisterLock = switch (lhs_mcv) { - .register => |reg| self.register_manager.lockRegAssumeUnused(reg), - else => null, - }; - defer if (lhs_lock) |lock| self.register_manager.unlockReg(lock); - - const actual_rhs_mcv: MCValue = blk: { - switch (signedness) { - .signed => { - const rhs_lock: ?RegisterLock = switch (rhs_mcv) { - .register => |reg| self.register_manager.lockRegAssumeUnused(reg), - else => null, - }; - defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); - - if (maybe_inst) |inst| { - break :blk try self.copyToRegisterWithInstTracking(inst, ty, rhs_mcv); - } - break :blk MCValue{ .register = try self.copyToTmpRegister(ty, rhs_mcv) }; - }, - .unsigned => break :blk rhs_mcv, - } - }; - const rhs_lock: ?RegisterLock = switch (actual_rhs_mcv) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (rhs_lock) |lock| self.register_manager.unlockReg(lock); - - switch (signedness) { - .signed => return try self.genInlineIntDivFloor(ty, lhs_mcv, actual_rhs_mcv), - .unsigned => { - try self.genIntMulDivOpMir(.{ ._, .div }, ty, lhs_mcv, actual_rhs_mcv); - return .{ .register = registerAlias(.rax, abi_size) }; - }, - } - }, - - else => unreachable, - } -} - fn genBinOp( self: *CodeGen, maybe_inst: ?Air.Inst.Index, @@ -171403,6 +176136,7 @@ fn genBinOp( .register_offset, .register_overflow, .register_mask, + .indirect_load_frame, .lea_frame, .load_nav, .lea_nav, @@ -172238,7 +176972,7 @@ fn genBinOp( lhs_reg, try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) { else => .fromSize(abi_size), - .vector => .fromBitSize(dst_reg.bitSize()), + .vector => dst_reg.size(), } }), ) else try self.asmRegisterRegisterRegister( mir_tag, @@ -172256,7 +176990,7 @@ fn genBinOp( dst_reg, try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) { else => .fromSize(abi_size), - .vector => .fromBitSize(dst_reg.bitSize()), + .vector => dst_reg.size(), } }), ) else try self.asmRegisterRegister( mir_tag, @@ -172284,7 +177018,7 @@ fn genBinOp( lhs_reg, try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) { else => .fromSize(abi_size), - .vector => .fromBitSize(dst_reg.bitSize()), + .vector => dst_reg.size(), } }), imm, ) else try self.asmRegisterRegisterRegisterImmediate( @@ -172304,7 +177038,7 @@ fn genBinOp( dst_reg, try src_mcv.mem(self, .{ .size = switch (lhs_ty.zigTypeTag(zcu)) { else => .fromSize(abi_size), - .vector => .fromBitSize(dst_reg.bitSize()), + .vector => dst_reg.size(), } }), imm, ) else try self.asmRegisterRegisterImmediate( @@ -172321,15 +177055,6 @@ fn genBinOp( } switch (air_tag) { - .add, .add_wrap, .sub, .sub_wrap, .mul, .mul_wrap, .div_float, .div_exact => {}, - .div_trunc, .div_floor => try self.genRound(lhs_ty, dst_reg, .{ .register = dst_reg }, .{ - .direction = switch (air_tag) { - .div_trunc => .zero, - .div_floor => .down, - else => unreachable, - }, - .precision = .inexact, - }), .bit_and, .bit_or, .xor => {}, .max, .min => if (maybe_mask_reg) |mask_reg| if (self.hasFeature(.avx)) { const rhs_copy_reg = registerAlias(src_mcv.getReg().?, abi_size); @@ -172596,6 +177321,7 @@ fn genBinOpMir( .lea_uav, .lea_lazy_sym, .lea_extern_func, + .indirect_load_frame, .elementwise_args, .reserved_frame, .air_ref, @@ -172632,6 +177358,7 @@ fn genBinOpMir( .undef, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, => unreachable, @@ -172803,6 +177530,7 @@ fn genBinOpMir( .undef, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, .air_ref, @@ -172906,6 +177634,7 @@ fn genBinOpMir( .undef, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, .air_ref, @@ -173036,6 +177765,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv .register_offset, .register_overflow, .register_mask, + .indirect_load_frame, .lea_frame, .lea_nav, .lea_uav, @@ -173073,6 +177803,7 @@ fn genIntMulComplexOpMir(self: *CodeGen, dst_ty: Type, dst_mcv: MCValue, src_mcv .register_quadruple, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, .air_ref, @@ -173195,11 +177926,20 @@ fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void { break :result src_mcv; }, .indirect => |reg_off| { - self.register_manager.getRegAssumeFree(reg_off.reg, inst); + 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, .{}); 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 } }, .{}); + break :result dst_mcv; + }, .elementwise_args => |regs_frame_addr| { try self.spillEflagsIfOccupied(); @@ -173398,18 +178138,6 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue }; } -fn airRetAddr(self: *CodeGen, inst: Air.Inst.Index) !void { - const dst_mcv = try self.allocRegOrMem(inst, true); - try self.genCopy(.usize, dst_mcv, .{ .load_frame = .{ .index = .ret_addr } }, .{}); - return self.finishAir(inst, dst_mcv, .{ .none, .none, .none }); -} - -fn airFrameAddress(self: *CodeGen, inst: Air.Inst.Index) !void { - const dst_mcv = try self.allocRegOrMem(inst, true); - try self.genCopy(.usize, dst_mcv, .{ .lea_frame = .{ .index = .base_ptr } }, .{}); - return self.finishAir(inst, dst_mcv, .{ .none, .none, .none }); -} - fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.builtin.CallModifier, opts: CopyOptions) !void { if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{}); @@ -173541,7 +178269,7 @@ fn genCall(self: *CodeGen, info: union(enum) { }, .load_frame => { try self.genCopy(arg_ty, dst_arg, src_arg, opts); - try self.freeValue(src_arg); + try self.freeValue(src_arg, .{}); }, .elementwise_args => |regs_frame_addr| { const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); @@ -174265,39 +178993,6 @@ fn airCmpVector(self: *CodeGen, inst: Air.Inst.Index) !void { return self.finishAir(inst, dst_mcv, .{ extra.lhs, extra.rhs, .none }); } -fn airCmpLtErrorsLen(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - - const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg); - defer self.register_manager.unlockReg(addr_lock); - const anyerror_lazy_sym: link.File.LazySymbol = .{ .kind = .const_data, .ty = .anyerror_type }; - try self.genLazySymbolRef(.lea, addr_reg, anyerror_lazy_sym); - - try self.spillEflagsIfOccupied(); - - const op_ty = self.typeOf(un_op); - const op_abi_size: u32 = @intCast(op_ty.abiSize(zcu)); - const op_mcv = try self.resolveInst(un_op); - const dst_reg = switch (op_mcv) { - .register => |reg| reg, - else => try self.copyToTmpRegister(op_ty, op_mcv), - }; - try self.asmRegisterMemory( - .{ ._, .cmp }, - registerAlias(dst_reg, op_abi_size), - .{ - .base = .{ .reg = addr_reg }, - .mod = .{ .rm = .{ .size = .fromSize(op_abi_size) } }, - }, - ); - - self.eflags_inst = inst; - return self.finishAir(inst, .{ .eflags = .b }, .{ un_op, .none, .none }); -} - fn airTry(self: *CodeGen, inst: Air.Inst.Index) !void { const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; const extra = self.air.extraData(Air.Try, pl_op.payload); @@ -174335,12 +179030,12 @@ fn genTry( const reloc = try self.genCondBrMir(.anyerror, is_err_mcv); if (self.liveness.operandDies(inst, 0)) { - if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst); + if (operand.toIndex()) |operand_inst| try self.processDeath(operand_inst, .{}); } const state = try self.saveState(); - for (liveness_cond_br.else_deaths) |death| try self.processDeath(death); + for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{}); try self.genBodyBlock(body); try self.restoreState(state, &.{}, .{ .emit_instructions = false, @@ -174351,7 +179046,7 @@ fn genTry( self.performReloc(reloc); - for (liveness_cond_br.then_deaths) |death| try self.processDeath(death); + for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{}); const result = if (self.liveness.isUnused(inst)) .unreach @@ -174362,33 +179057,6 @@ fn genTry( return result; } -fn airDbgVar(cg: *CodeGen, inst: Air.Inst.Index) !void { - if (cg.mod.strip) return; - const air_tag = cg.air.instructions.items(.tag)[@intFromEnum(inst)]; - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; - const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); - const op_ty = cg.typeOf(pl_op.operand); - const local_ty = switch (air_tag) { - else => unreachable, - .dbg_var_ptr => op_ty.childType(cg.pt.zcu), - .dbg_var_val, .dbg_arg_inline => op_ty, - }; - - try cg.mir_locals.append(cg.gpa, .{ - .name = switch (air_name) { - .none => switch (air_tag) { - else => unreachable, - .dbg_arg_inline => .none, - }, - else => try cg.addString(air_name.toSlice(cg.air)), - }, - .type = local_ty.toIntern(), - }); - - try cg.genLocalDebugInfo(air_tag, local_ty, try cg.resolveInst(pl_op.operand)); - return cg.finishAir(inst, .unreach, .{ pl_op.operand, .none, .none }); -} - fn genCondBrMir(self: *CodeGen, ty: Type, mcv: MCValue) !Mir.Inst.Index { const pt = self.pt; const abi_size = ty.abiSize(pt.zcu); @@ -174431,13 +179099,13 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void { // that death now instead of later as this has an effect on // whether it needs to be spilled in the branches if (self.liveness.operandDies(inst, 0)) { - if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst); + if (pl_op.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{}); } const state = try self.saveState(); const reloc = try self.genCondBrMir(cond_ty, cond); - for (liveness_cond_br.then_deaths) |death| try self.processDeath(death); + for (liveness_cond_br.then_deaths) |death| try self.processDeath(death, .{}); try self.genBodyBlock(then_body); try self.restoreState(state, &.{}, .{ .emit_instructions = false, @@ -174448,7 +179116,7 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void { self.performReloc(reloc); - for (liveness_cond_br.else_deaths) |death| try self.processDeath(death); + for (liveness_cond_br.else_deaths) |death| try self.processDeath(death, .{}); try self.genBodyBlock(else_body); try self.restoreState(state, &.{}, .{ .emit_instructions = false, @@ -174460,177 +179128,6 @@ fn airCondBr(self: *CodeGen, inst: Air.Inst.Index) !void { // We already took care of pl_op.operand earlier, so there's nothing left to do. } -fn isNull(self: *CodeGen, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MCValue { - const pt = self.pt; - const zcu = pt.zcu; - switch (opt_mcv) { - .register_overflow => |ro| return .{ .eflags = ro.eflags.negate() }, - else => {}, - } - - try self.spillEflagsIfOccupied(); - - const pl_ty = opt_ty.optionalChild(zcu); - - const some_info: struct { off: u31, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu)) - .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty } - else - .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = .bool }; - - self.eflags_inst = inst; - switch (opt_mcv) { - .none, - .unreach, - .dead, - .undef, - .immediate, - .eflags, - .register_triple, - .register_quadruple, - .register_offset, - .register_overflow, - .register_mask, - .lea_nav, - .lea_uav, - .lea_lazy_sym, - .lea_extern_func, - .elementwise_args, - .reserved_frame, - .air_ref, - => unreachable, - - .lea_frame => { - self.eflags_inst = null; - return .{ .immediate = @intFromBool(false) }; - }, - - .register => |opt_reg| { - if (some_info.off == 0) { - const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu)); - const alias_reg = registerAlias(opt_reg, some_abi_size); - assert(some_abi_size * 8 == alias_reg.bitSize()); - try self.asmRegisterRegister(.{ ._, .@"test" }, alias_reg, alias_reg); - return .{ .eflags = .z }; - } - assert(some_info.ty.ip_index == .bool_type); - const opt_abi_size: u32 = @intCast(opt_ty.abiSize(zcu)); - try self.asmRegisterImmediate( - .{ ._, .bt }, - registerAlias(opt_reg, opt_abi_size), - .u(@as(u6, @intCast(some_info.off * 8))), - ); - return .{ .eflags = .nc }; - }, - - .register_pair => |opt_regs| { - if (some_info.off == 0) { - const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu)); - const alias_reg = registerAlias(opt_regs[0], some_abi_size); - assert(some_abi_size * 8 == alias_reg.bitSize()); - try self.asmRegisterRegister(.{ ._, .@"test" }, alias_reg, alias_reg); - return .{ .eflags = .z }; - } - assert(some_info.ty.ip_index == .bool_type); - const opt_abi_size: u32 = @intCast(opt_ty.abiSize(zcu)); - try self.asmRegisterImmediate( - .{ ._, .bt }, - registerAlias(opt_regs[some_info.off / 8], opt_abi_size), - .u(@as(u6, @truncate(some_info.off * 8))), - ); - return .{ .eflags = .nc }; - }, - - .memory, - .load_nav, - .load_uav, - .load_lazy_sym, - .load_extern_func, - => { - const addr_reg = (try self.register_manager.allocReg(null, abi.RegisterClass.gp)).to64(); - const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg); - defer self.register_manager.unlockReg(addr_reg_lock); - - try self.genSetReg(addr_reg, .usize, opt_mcv.address(), .{}); - const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu)); - try self.asmMemoryImmediate( - .{ ._, .cmp }, - .{ - .base = .{ .reg = addr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(some_abi_size), - .disp = some_info.off, - } }, - }, - .u(0), - ); - return .{ .eflags = .e }; - }, - - .indirect, .load_frame => { - const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu)); - try self.asmMemoryImmediate( - .{ ._, .cmp }, - switch (opt_mcv) { - .indirect => |reg_off| .{ - .base = .{ .reg = reg_off.reg }, - .mod = .{ .rm = .{ - .size = .fromSize(some_abi_size), - .disp = reg_off.off + some_info.off, - } }, - }, - .load_frame => |frame_addr| .{ - .base = .{ .frame = frame_addr.index }, - .mod = .{ .rm = .{ - .size = .fromSize(some_abi_size), - .disp = frame_addr.off + some_info.off, - } }, - }, - else => unreachable, - }, - .u(0), - ); - return .{ .eflags = .e }; - }, - } -} - -fn isNullPtr(self: *CodeGen, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue { - const pt = self.pt; - const zcu = pt.zcu; - const opt_ty = ptr_ty.childType(zcu); - const pl_ty = opt_ty.optionalChild(zcu); - - try self.spillEflagsIfOccupied(); - - const some_info: struct { off: i32, ty: Type } = if (opt_ty.optionalReprIsPayload(zcu)) - .{ .off = 0, .ty = if (pl_ty.isSlice(zcu)) pl_ty.slicePtrFieldType(zcu) else pl_ty } - else - .{ .off = @intCast(pl_ty.abiSize(zcu)), .ty = .bool }; - - const ptr_reg = switch (ptr_mcv) { - .register => |reg| reg, - else => try self.copyToTmpRegister(ptr_ty, ptr_mcv), - }; - const ptr_lock = self.register_manager.lockReg(ptr_reg); - defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock); - - const some_abi_size: u32 = @intCast(some_info.ty.abiSize(zcu)); - try self.asmMemoryImmediate( - .{ ._, .cmp }, - .{ - .base = .{ .reg = ptr_reg }, - .mod = .{ .rm = .{ - .size = .fromSize(some_abi_size), - .disp = some_info.off, - } }, - }, - .u(0), - ); - - self.eflags_inst = inst; - return .{ .eflags = .e }; -} - fn isErr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue { const pt = self.pt; const zcu = pt.zcu; @@ -174708,124 +179205,6 @@ fn isErrPtr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv: return MCValue{ .eflags = .a }; } -fn isNonErr(self: *CodeGen, inst: Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MCValue { - const is_err_res = try self.isErr(inst, eu_ty, eu_mcv); - switch (is_err_res) { - .eflags => |cc| { - assert(cc == .a); - return MCValue{ .eflags = cc.negate() }; - }, - .immediate => |imm| { - assert(imm == 0); - return MCValue{ .immediate = @intFromBool(imm == 0) }; - }, - else => unreachable, - } -} - -fn isNonErrPtr(self: *CodeGen, inst: Air.Inst.Index, ptr_ty: Type, ptr_mcv: MCValue) !MCValue { - const is_err_res = try self.isErrPtr(inst, ptr_ty, ptr_mcv); - switch (is_err_res) { - .eflags => |cc| { - assert(cc == .a); - return MCValue{ .eflags = cc.negate() }; - }, - .immediate => |imm| { - assert(imm == 0); - return MCValue{ .immediate = @intFromBool(imm == 0) }; - }, - else => unreachable, - } -} - -fn airIsNull(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isNull(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsNullPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isNullPtr(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsNonNull(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result: MCValue = switch (try self.isNull(inst, ty, operand)) { - .immediate => |imm| .{ .immediate = @intFromBool(imm == 0) }, - .eflags => |cc| .{ .eflags = cc.negate() }, - else => unreachable, - }; - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsNonNullPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result: MCValue = switch (try self.isNullPtr(inst, ty, operand)) { - .eflags => |cc| .{ .eflags = cc.negate() }, - else => unreachable, - }; - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsErr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isErr(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsErrPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isErrPtr(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsNonErr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isNonErr(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airIsNonErrPtr(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const operand = try self.resolveInst(un_op); - const ty = self.typeOf(un_op); - const result = try self.isNonErrPtr(inst, ty, operand); - return self.finishAir(inst, result, .{ un_op, .none, .none }); -} - -fn airLoop(self: *CodeGen, inst: Air.Inst.Index) !void { - // A loop is a setup to be able to jump back to the beginning. - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const loop = self.air.extraData(Air.Block, ty_pl.payload); - const body: []const Air.Inst.Index = @ptrCast(self.air.extra.items[loop.end..][0..loop.data.body_len]); - - const state = try self.saveState(); - - try self.loops.putNoClobber(self.gpa, inst, .{ - .state = state, - .target = @intCast(self.mir_instructions.len), - }); - defer assert(self.loops.remove(inst)); - - try self.genBodyBlock(body); -} - fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void { // A block is a setup to be able to jump to the end. const inst_tracking_i = self.inst_tracking.count(); @@ -174860,7 +179239,7 @@ fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index if (std.debug.runtime_safety) assert(self.inst_tracking.getIndex(inst).? == inst_tracking_i); const tracking = &self.inst_tracking.values()[inst_tracking_i]; - if (self.liveness.isUnused(inst)) try tracking.die(self, inst); + if (self.liveness.isUnused(inst)) try tracking.die(self, inst, .{}); self.getValueIfFree(tracking.short, inst); } @@ -175019,7 +179398,7 @@ fn lowerSwitchBr( } } - for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand); + for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{}); try cg.genBodyBlock(case.body); try cg.restoreState(state, &.{}, .{ @@ -175033,7 +179412,7 @@ fn lowerSwitchBr( const else_body = cases_it.elseBody(); const else_deaths = liveness.deaths.len - 1; - for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand); + for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{}); cg.performReloc(else_reloc); if (is_loop) { @@ -175151,7 +179530,7 @@ fn lowerSwitchBr( // The jump to skip this case if the conditions all failed. const skip_case_reloc = try cg.asmJmpReloc(undefined); - for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand); + for (liveness.deaths[case.idx]) |operand| try cg.processDeath(operand, .{}); // Relocate all success cases to the body we're about to generate. for (relocs) |reloc| cg.performReloc(reloc); @@ -175170,7 +179549,7 @@ fn lowerSwitchBr( const else_body = cases_it.elseBody(); const else_deaths = liveness.deaths.len - 1; - for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand); + for (liveness.deaths[else_deaths]) |operand| try cg.processDeath(operand, .{}); try cg.genBodyBlock(else_body); try cg.restoreState(state, &.{}, .{ @@ -175191,7 +179570,7 @@ fn airSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void { // whether it needs to be spilled in the branches const condition_dies = self.liveness.operandDies(inst, 0); if (condition_dies) { - if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst); + if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{}); } try self.lowerSwitchBr(inst, switch_br, condition, condition_dies, false); @@ -175216,7 +179595,7 @@ fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void { // that death now instead of later as this has an effect on // whether it needs to be spilled in the branches if (self.liveness.operandDies(inst, 0)) { - if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst); + if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{}); } // Ensure a register is available for dispatch. @@ -175231,11 +179610,11 @@ fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void { defer assert(self.loops.remove(inst)); // Stop tracking block result without forgetting tracking info - try self.freeValue(mat_cond); + try self.freeValue(mat_cond, .{}); try self.lowerSwitchBr(inst, switch_br, mat_cond, true, true); - try self.processDeath(inst); + try self.processDeath(inst, .{}); } fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { @@ -175262,7 +179641,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { // Process operand death so that it is properly accounted for in the State below. if (self.liveness.operandDies(inst, 0)) { - if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst); + if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{}); } try self.restoreState(loop_data.state, &.{}, .{ @@ -175340,7 +179719,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { _ = try self.asmJmpReloc(loop_data.target); // Stop tracking block result without forgetting tracking info - try self.freeValue(block_tracking.short); + try self.freeValue(block_tracking.short, .{ .emit_instructions = false }); } fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void { @@ -175389,10 +179768,14 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void { if (first_br) break :result src_mcv; try self.getValue(block_tracking.short, br.block_inst); - // .long = .none to avoid merging operand and block result stack frames. - const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv }; - try current_tracking.materializeUnsafe(self, br.block_inst, block_tracking.*); - for (current_tracking.getRegs()) |src_reg| self.register_manager.freeReg(src_reg); + try InstTracking.materializeUnsafe( + // .long = .none to avoid merging operand and block result stack frames. + .{ .long = .none, .short = src_mcv }, + self, + br.block_inst, + block_tracking.*, + ); + try self.freeValue(src_mcv, .{}); break :result block_tracking.short; } @@ -175406,7 +179789,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void { // Process operand death so that it is properly accounted for in the State below. if (self.liveness.operandDies(inst, 0)) { - if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst); + if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst, .{}); } if (first_br) { @@ -175425,7 +179808,7 @@ fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void { try block_data.relocs.append(self.gpa, jmp_reloc); // Stop tracking block result without forgetting tracking info - try self.freeValue(block_tracking.short); + try self.freeValue(block_tracking.short, .{ .emit_instructions = false }); } fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { @@ -175802,7 +180185,7 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { } }, } }; } else { - if (mnem_size.use()) |size| if (reg.bitSize() != size.bitSize(self.target)) + if (mnem_size.use()) |size| if (reg.size().bitSize(self.target) != size.bitSize(self.target)) return self.fail("invalid register size: '{s}'", .{op_str}); op.* = .{ .reg = reg }; } @@ -176181,7 +180564,7 @@ const MoveStrategy = union(enum) { if (tag[0] == ._ps and tag[1] == .movl) try cg.asmRegisterRegister(.{ ._ps, .xor }, dst_reg, dst_reg); try cg.asmRegisterMemory(tag, switch (tag[1]) { else => dst_reg, - .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), + .lea => if (dst_reg.size().bitSize(cg.target) >= 32) dst_reg else dst_reg.to32(), }, src_mem); }, .load_store_x87 => if (dst_reg != .st0 and cg.register_manager.isKnownRegFree(.st7)) { @@ -176554,6 +180937,7 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C .eflags, .register_overflow, .register_mask, + .indirect_load_frame, .lea_frame, .lea_nav, .lea_uav, @@ -176750,12 +181134,13 @@ fn genSetReg( 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.bitSize()) + if (ty.bitSize(zcu) > dst_alias.size().bitSize(self.target)) return self.fail("genSetReg called with a value larger than dst_reg", .{}); switch (src_mcv) { .none, .unreach, .dead, + .indirect_load_frame, .elementwise_args, .reserved_frame, => unreachable, @@ -177112,7 +181497,7 @@ fn genSetReg( ty, dst_reg.class(), self.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units( - std.math.log2_int_ceil(u10, @divExact(dst_reg.bitSize(), 8)), + std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(self.target), 8)), )), ), .lea_frame => .{ .load_store = .{ ._, .lea } }, @@ -177318,6 +181703,7 @@ fn genSetMem( .none, .unreach, .dead, + .indirect_load_frame, .elementwise_args, .reserved_frame, => unreachable, @@ -177382,43 +181768,37 @@ fn genSetMem( 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)]; 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; + 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: u32 = switch (src_class) { - .general_purpose, .gphi, .segment, .ip, .cr, .dr => @intCast(@divExact(src_alias.bitSize(), 8)), - .mmx, .sse => abi_size, + const src_size: Memory.Size = switch (src_class) { + .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]) { else => unreachable, - .float, .float_combine => 4, - .sse => 8, - .x87 => 10, + .float => .dword, + .float_combine, .sse => .qword, + .x87 => .tbyte, }, }; - const src_align: InternPool.Alignment = .fromNonzeroByteUnits( - std.math.ceilPowerOfTwoAssert(u32, src_size), - ); - if (src_size > mem_size) { + const src_bit_size = src_size.bitSize(self.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(.{ - .size = src_size, + .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, - .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ - .size = .fromSize(src_size), - } } }, - src_alias, - ); + try (try self.moveStrategy(ty, src_class, true)).write(self, .{ + .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); + try self.freeValue(frame_mcv, .{}); } else try (try self.moveStrategy(ty, src_class, switch (base) { .none => src_align.check(@as(u32, @bitCast(disp))), .reg => |reg| switch (reg) { @@ -177432,17 +181812,10 @@ fn genSetMem( .table, .rip_inst, .lazy_sym, .extern_func => unreachable, .nav => |nav| ip.getNav(nav).getAlignment().compare(.gte, src_align), .uav => |uav| Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).compare(.gte, src_align), - })).write( - self, - .{ .base = base, .mod = .{ .rm = .{ - .size = .fromBitSize(@min( - self.memSize(ty).bitSize(self.target), - src_alias.bitSize(), - )), - .disp = disp, - } } }, - src_alias, - ); + })).write(self, .{ + .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; @@ -178582,271 +182955,6 @@ fn airMemset(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { return self.finishAir(inst, .unreach, .{ bin_op.lhs, bin_op.rhs, .none }); } -fn airMemcpy(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; - - try self.spillRegisters(&.{ .rdi, .rsi, .rcx }); - const reg_locks = self.register_manager.lockRegsAssumeUnused(3, .{ .rdi, .rsi, .rcx }); - defer for (reg_locks) |lock| self.register_manager.unlockReg(lock); - - const dst = try self.resolveInst(bin_op.lhs); - const dst_ty = self.typeOf(bin_op.lhs); - const dst_locks: [2]?RegisterLock = switch (dst) { - .register => |dst_reg| .{ self.register_manager.lockRegAssumeUnused(dst_reg), null }, - .register_pair => |dst_regs| .{ - self.register_manager.lockRegAssumeUnused(dst_regs[0]), - self.register_manager.lockReg(dst_regs[1]), - }, - else => @splat(null), - }; - for (dst_locks) |dst_lock| if (dst_lock) |lock| self.register_manager.unlockReg(lock); - - const src = try self.resolveInst(bin_op.rhs); - const src_locks: [2]?RegisterLock = switch (src) { - .register => |src_reg| .{ self.register_manager.lockReg(src_reg), null }, - .register_pair => |src_regs| .{ - self.register_manager.lockRegAssumeUnused(src_regs[0]), - self.register_manager.lockRegAssumeUnused(src_regs[1]), - }, - else => @splat(null), - }; - for (src_locks) |src_lock| if (src_lock) |lock| self.register_manager.unlockReg(lock); - - const len: MCValue = switch (dst_ty.ptrSize(zcu)) { - .slice => len: { - const len_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const len_lock = self.register_manager.lockRegAssumeUnused(len_reg); - defer self.register_manager.unlockReg(len_lock); - - switch (dst) { - .register_pair => |dst_regs| try self.asmRegisterRegisterImmediate( - .{ .i_, .mul }, - len_reg, - dst_regs[1], - .s(@intCast(dst_ty.childType(zcu).abiSize(zcu))), - ), - else => try self.asmRegisterMemoryImmediate( - .{ .i_, .mul }, - len_reg, - try dst.address().offset(8).deref().mem(self, .{ .size = .qword }), - .s(@intCast(dst_ty.childType(zcu).abiSize(zcu))), - ), - } - break :len .{ .register = len_reg }; - }, - .one => len: { - const array_ty = dst_ty.childType(zcu); - break :len .{ .immediate = array_ty.arrayLen(zcu) * array_ty.childType(zcu).abiSize(zcu) }; - }, - .c, .many => unreachable, - }; - const len_lock: ?RegisterLock = switch (len) { - .register => |reg| self.register_manager.lockReg(reg), - else => null, - }; - defer if (len_lock) |lock| self.register_manager.unlockReg(lock); - - const dst_ptr: MCValue = switch (dst) { - .register_pair => |dst_regs| .{ .register = dst_regs[0] }, - else => dst, - }; - const src_ptr: MCValue = switch (src) { - .register_pair => |src_regs| .{ .register = src_regs[0] }, - else => src, - }; - - try self.genInlineMemcpy(dst_ptr, src_ptr, len, .{ .no_alias = true }); - - return self.finishAir(inst, .unreach, .{ bin_op.lhs, bin_op.rhs, .none }); -} - -fn airTagName(self: *CodeGen, inst: Air.Inst.Index, only_safety: bool) !void { - const pt = self.pt; - const zcu = pt.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - const inst_ty = self.typeOfIndex(inst); - const enum_ty = self.typeOf(un_op); - - // We need a properly aligned and sized call frame to be able to call this function. - { - const needed_call_frame: FrameAlloc = .init(.{ - .size = inst_ty.abiSize(zcu), - .alignment = inst_ty.abiAlignment(zcu), - }); - const frame_allocs_slice = self.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); - const stack_frame_align = - &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; - stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align); - } - - var param_gpr = abi.getCAbiIntParamRegs(.auto); - const err_ret_trace_reg = if (zcu.comp.config.any_error_tracing) err_ret_trace_reg: { - defer param_gpr = param_gpr[0 .. param_gpr.len - 1]; - break :err_ret_trace_reg param_gpr[param_gpr.len - 1]; - } else .none; - - try self.spillEflagsIfOccupied(); - try self.spillCallerPreservedRegs(.auto, err_ret_trace_reg); - - const operand = try self.resolveInst(un_op); - try self.genSetReg(param_gpr[0], enum_ty, operand, .{}); - - const enum_lazy_sym: link.File.LazySymbol = .{ .kind = .code, .ty = enum_ty.toIntern() }; - try self.genLazySymbolRef(.call, abi.getCAbiLinkerScratchReg(.auto), enum_lazy_sym); - - const tag_name_regs = param_gpr[0..2].*; - const dst_mcv: MCValue = if (only_safety) result: { - try self.asmRegisterRegister(.{ ._, .@"test" }, tag_name_regs[0].to64(), tag_name_regs[0].to64()); - break :result .{ .eflags = .nz }; - } else .{ .register_pair = tag_name_regs }; - return self.finishAir(inst, dst_mcv, .{ un_op, .none, .none }); -} - -fn airErrorName(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; - - const err_ty = self.typeOf(un_op); - const err_mcv = try self.resolveInst(un_op); - const err_reg = try self.copyToTmpRegister(err_ty, err_mcv); - const err_lock = self.register_manager.lockRegAssumeUnused(err_reg); - defer self.register_manager.unlockReg(err_lock); - - const addr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg); - defer self.register_manager.unlockReg(addr_lock); - const anyerror_lazy_sym: link.File.LazySymbol = .{ .kind = .const_data, .ty = .anyerror_type }; - try self.genLazySymbolRef(.lea, addr_reg, anyerror_lazy_sym); - - const start_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const start_lock = self.register_manager.lockRegAssumeUnused(start_reg); - defer self.register_manager.unlockReg(start_lock); - - const end_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const end_lock = self.register_manager.lockRegAssumeUnused(end_reg); - defer self.register_manager.unlockReg(end_lock); - - try self.truncateRegister(err_ty, err_reg.to32()); - - try self.asmRegisterMemory( - .{ ._, .mov }, - start_reg.to32(), - .{ - .base = .{ .reg = addr_reg.to64() }, - .mod = .{ .rm = .{ - .size = .dword, - .index = err_reg.to64(), - .scale = .@"4", - .disp = (1 - 1) * 4, - } }, - }, - ); - try self.asmRegisterMemory( - .{ ._, .mov }, - end_reg.to32(), - .{ - .base = .{ .reg = addr_reg.to64() }, - .mod = .{ .rm = .{ - .size = .dword, - .index = err_reg.to64(), - .scale = .@"4", - .disp = (2 - 1) * 4, - } }, - }, - ); - try self.asmRegisterRegister(.{ ._, .sub }, end_reg.to32(), start_reg.to32()); - try self.asmRegisterMemory( - .{ ._, .lea }, - start_reg.to64(), - .{ - .base = .{ .reg = addr_reg.to64() }, - .mod = .{ .rm = .{ .index = start_reg.to64() } }, - }, - ); - try self.asmRegisterMemory( - .{ ._, .lea }, - end_reg.to32(), - .{ - .base = .{ .reg = end_reg.to64() }, - .mod = .{ .rm = .{ .disp = -1 } }, - }, - ); - - const dst_mcv = try self.allocRegOrMem(inst, false); - try self.asmMemoryRegister( - .{ ._, .mov }, - .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .disp = dst_mcv.load_frame.off, - } }, - }, - start_reg.to64(), - ); - try self.asmMemoryRegister( - .{ ._, .mov }, - .{ - .base = .{ .frame = dst_mcv.load_frame.index }, - .mod = .{ .rm = .{ - .size = .qword, - .disp = dst_mcv.load_frame.off + 8, - } }, - }, - end_reg.to64(), - ); - - return self.finishAir(inst, dst_mcv, .{ un_op, .none, .none }); -} - -fn airErrorSetHasValue(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; - const inst_ty = self.typeOfIndex(inst); - const err_ty = ty_op.ty.toType(); - - // We need a properly aligned and sized call frame to be able to call this function. - { - const needed_call_frame: FrameAlloc = .init(.{ - .size = inst_ty.abiSize(zcu), - .alignment = inst_ty.abiAlignment(zcu), - }); - const frame_allocs_slice = self.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); - const stack_frame_align = - &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; - stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align); - } - - var param_gpr = abi.getCAbiIntParamRegs(.auto); - const err_ret_trace_reg = if (zcu.comp.config.any_error_tracing) err_ret_trace_reg: { - defer param_gpr = param_gpr[0 .. param_gpr.len - 1]; - break :err_ret_trace_reg param_gpr[param_gpr.len - 1]; - } else .none; - - try self.spillEflagsIfOccupied(); - try self.spillCallerPreservedRegs(.auto, err_ret_trace_reg); - - const operand = try self.resolveInst(ty_op.operand); - try self.genSetReg(param_gpr[0], err_ty, operand, .{}); - - const enum_lazy_sym: link.File.LazySymbol = .{ .kind = .code, .ty = err_ty.toIntern() }; - try self.genLazySymbolRef(.call, abi.getCAbiLinkerScratchReg(.auto), enum_lazy_sym); - - const res_reg = param_gpr[0]; - try self.asmRegisterRegister(.{ ._, .@"test" }, res_reg.to32(), res_reg.to32()); - - const dst_mcv: MCValue = .{ .eflags = .nz }; - return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none }); -} - fn airSplat(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; @@ -180451,120 +184559,6 @@ fn airShuffle(self: *CodeGen, inst: Air.Inst.Index) !void { return self.finishAir(inst, result, .{ extra.a, extra.b, .none }); } -fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { - const pt = self.pt; - const zcu = pt.zcu; - const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce; - - const result: MCValue = result: { - const operand_ty = self.typeOf(reduce.operand); - if (operand_ty.isVector(zcu) and operand_ty.childType(zcu).toIntern() == .bool_type) { - try self.spillEflagsIfOccupied(); - - const abi_size: u32 = @intCast(operand_ty.abiSize(zcu)); - const operand_mcv = try self.resolveInst(reduce.operand); - const mask_len = operand_ty.vectorLen(zcu); - const mask_len_minus_one = (std.math.cast(u6, mask_len - 1) orelse { - const acc_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); - const acc_lock = self.register_manager.lockRegAssumeUnused(acc_reg); - defer self.register_manager.unlockReg(acc_lock); - var limb_offset: i31 = @intCast((mask_len - 1) / 64 * 8); - const need_mask = mask_len % 64 != 0; - if (need_mask) try self.asmRegisterImmediate( - .{ ._, .mov }, - if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(), - .u((@as(u64, std.math.maxInt(u64)) >> @truncate(-%mask_len))), - ); - const operand_mem_mcv: MCValue = if (!operand_mcv.isBase()) operand_mem: { - const frame_index = try self.allocFrameIndex(.initSpill(operand_ty, zcu)); - try self.genSetMem(.{ .frame = frame_index }, 0, operand_ty, operand_mcv, .{}); - break :operand_mem .{ .load_frame = .{ .index = frame_index } }; - } else operand_mcv; - var first = true; - while (true) : (limb_offset -= 8) { - try self.asmRegisterMemory( - .{ ._, if (first) if (need_mask) .@"and" else .mov else switch (reduce.operation) { - .Or => .@"or", - .And => .@"and", - else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), - } }, - acc_reg.to64(), - try operand_mem_mcv.mem(self, .{ - .size = .qword, - .disp = limb_offset, - }), - ); - if (limb_offset == 0) break; - first = false; - } - switch (reduce.operation) { - .Or => { - try self.asmRegisterRegister(.{ ._, .@"test" }, acc_reg.to64(), acc_reg.to64()); - break :result .{ .eflags = .nz }; - }, - .And => { - try self.asmRegisterImmediate(.{ ._, .cmp }, acc_reg.to64(), .s(-1)); - break :result .{ .eflags = .z }; - }, - else => unreachable, - } - }); - const mask = @as(u64, std.math.maxInt(u64)) >> ~mask_len_minus_one; - switch (reduce.operation) { - .Or => { - if (operand_mcv.isBase()) try self.asmMemoryImmediate( - .{ ._, .@"test" }, - try operand_mcv.mem(self, .{ .size = .fromSize(abi_size) }), - if (mask_len < abi_size * 8) - .u(mask) - else - .s(-1), - ) else { - const operand_reg = registerAlias(operand_reg: { - if (operand_mcv.isRegister()) { - const operand_reg = operand_mcv.getReg().?; - if (operand_reg.isClass(.general_purpose)) break :operand_reg operand_reg; - } - break :operand_reg try self.copyToTmpRegister(operand_ty, operand_mcv); - }, abi_size); - const operand_lock = self.register_manager.lockReg(operand_reg); - defer if (operand_lock) |lock| self.register_manager.unlockReg(lock); - - if (mask_len < abi_size * 8) try self.asmRegisterImmediate( - .{ ._, .@"test" }, - operand_reg, - .u(mask), - ) else try self.asmRegisterRegister( - .{ ._, .@"test" }, - operand_reg, - operand_reg, - ); - } - break :result .{ .eflags = .nz }; - }, - .And => { - const tmp_reg = registerAlias( - try self.copyToTmpRegister(operand_ty, operand_mcv), - abi_size, - ); - const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg); - defer self.register_manager.unlockReg(tmp_lock); - - try self.asmRegister(.{ ._, .not }, tmp_reg); - if (mask_len < abi_size * 8) - try self.asmRegisterImmediate(.{ ._, .@"test" }, tmp_reg, .u(mask)) - else - try self.asmRegisterRegister(.{ ._, .@"test" }, tmp_reg, tmp_reg); - break :result .{ .eflags = .z }; - }, - else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), - } - } - return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}); - }; - return self.finishAir(inst, result, .{ reduce.operand, .none, .none }); -} - fn airAggregateInit(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; @@ -181278,14 +185272,16 @@ const CallMCValues = struct { } }; +const win64_shadow_space = 8 * 4; + /// Caller must call `CallMCValues.deinit`. fn resolveCallingConventionValues( - self: *CodeGen, + cg: *CodeGen, fn_info: InternPool.Key.FuncType, var_args: []const Type, stack_frame_base: FrameIndex, ) !CallMCValues { - const pt = self.pt; + const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; const cc = fn_info.cc; @@ -181294,7 +185290,7 @@ fn resolveCallingConventionValues( param_types: [32][@sizeOf(Type)]u8 align(@alignOf(Type)), }; var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) = - std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa); + std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa); const allocator = stack.get(); const param_types = try allocator.alloc(Type, fn_info.param_types.len + var_args.len); @@ -181303,10 +185299,10 @@ fn resolveCallingConventionValues( for (param_types[0..fn_info.param_types.len], fn_info.param_types.get(ip)) |*param_ty, arg_ty| param_ty.* = .fromInterned(arg_ty); for (param_types[fn_info.param_types.len..], var_args) |*param_ty, arg_ty| - param_ty.* = self.promoteVarArg(arg_ty); + param_ty.* = cg.promoteVarArg(arg_ty); var result: CallMCValues = .{ - .args = try self.gpa.alloc(MCValue, param_types.len), + .args = try cg.gpa.alloc(MCValue, param_types.len), .air_arg_count = 0, // These undefined values must be populated before returning from this function. .return_value = undefined, @@ -181316,29 +185312,30 @@ fn resolveCallingConventionValues( .fp_count = 0, .err_ret_trace_reg = .none, }; - errdefer self.gpa.free(result.args); + errdefer cg.gpa.free(result.args); const ret_ty: Type = .fromInterned(fn_info.return_type); switch (cc) { .naked => { assert(result.args.len == 0); result.return_value = .init(.unreach); - result.stack_align = switch (self.target.cpu.arch) { + result.stack_align = switch (cg.target.cpu.arch) { else => unreachable, .x86 => .@"4", .x86_64 => .@"8", }; }, .x86_64_sysv, .x86_64_win => |cc_opts| { - var ret_int_reg_i: u32 = 0; - var ret_sse_reg_i: u32 = 0; - var param_int_reg_i: u32 = 0; - var param_sse_reg_i: u32 = 0; + const param_gpr = abi.getCAbiIntParamRegs(cc); + var param_gpr_index: u32 = 0; + const param_sse = abi.getCAbiSseParamRegs(cc, cg.target); + var param_sse_index: u32 = 0; + result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16); switch (cc) { .x86_64_sysv => {}, - .x86_64_win => result.stack_byte_count += @intCast(4 * 8), + .x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space), else => unreachable, } @@ -181350,62 +185347,56 @@ fn resolveCallingConventionValues( result.return_value = .init(.none); } else { var ret_tracking: [4]InstTracking = undefined; - var ret_tracking_i: usize = 0; + var ret_tracking_len: u32 = 0; + var ret_gpr = abi.getCAbiIntReturnRegs(cc); + var ret_sse = abi.getCAbiSseReturnRegs(cc); + var ret_x87 = abi.getCAbiX87ReturnRegs(cc); const classes = switch (cc) { - .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, self.target, .ret), .none), - .x86_64_win => &.{abi.classifyWindows(ret_ty, zcu)}, + .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)}, else => unreachable, }; for (classes) |class| switch (class) { .integer => { - const ret_int_reg = registerAlias( - abi.getCAbiIntReturnRegs(cc)[ret_int_reg_i], + ret_tracking[ret_tracking_len] = .init(.{ .register = registerAlias( + ret_gpr[0], @intCast(@min(ret_ty.abiSize(zcu), 8)), - ); - ret_int_reg_i += 1; - - ret_tracking[ret_tracking_i] = .init(.{ .register = ret_int_reg }); - ret_tracking_i += 1; + ) }); + ret_tracking_len += 1; + ret_gpr = ret_gpr[1..]; }, .sse, .float, .float_combine, .win_i128 => { - const ret_sse_regs = abi.getCAbiSseReturnRegs(cc); const abi_size: u32 = @intCast(ret_ty.abiSize(zcu)); - const reg_size = @min(abi_size, self.vectorSize(.float)); + 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_regs[ret_sse_reg_i], reg_size); - ret_sse_reg_i += 1; + const ret_sse_reg = registerAlias(ret_sse[0], reg_size); + ret_sse = ret_sse[1..]; - ret_tracking[ret_tracking_i] = .init(.{ .register = ret_sse_reg }); - ret_tracking_i += 1; + ret_tracking[ret_tracking_len] = .init(.{ .register = ret_sse_reg }); + ret_tracking_len += 1; } }, - .sseup => assert(ret_tracking[ret_tracking_i - 1].short.register.isClass(.sse)), + .sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)), .x87 => { - ret_tracking[ret_tracking_i] = .init(.{ .register = abi.getCAbiX87ReturnRegs(cc)[0] }); - ret_tracking_i += 1; - }, - .x87up => assert(ret_tracking[ret_tracking_i - 1].short.register.isClass(.x87)), - .complex_x87 => { - ret_tracking[ret_tracking_i] = .init(.{ .register_pair = abi.getCAbiX87ReturnRegs(cc)[0..2].* }); - ret_tracking_i += 1; - }, - .memory => { - const ret_int_reg = abi.getCAbiIntReturnRegs(cc)[ret_int_reg_i].to64(); - ret_int_reg_i += 1; - const ret_indirect_reg = abi.getCAbiIntParamRegs(cc)[param_int_reg_i]; - param_int_reg_i += 1; - - ret_tracking[ret_tracking_i] = .{ - .short = .{ .indirect = .{ .reg = ret_int_reg } }, - .long = .{ .indirect = .{ .reg = ret_indirect_reg } }, + 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)), + .memory, .integer_per_element => { + ret_tracking[ret_tracking_len] = .{ + .short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } }, + .long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } }, }; - ret_tracking_i += 1; + ret_tracking_len += 1; + ret_gpr = ret_gpr[1..]; + param_gpr_index += 1; }, - .none, .integer_per_element => unreachable, + .none => unreachable, }; - result.return_value = switch (ret_tracking_i) { + result.return_value = switch (ret_tracking_len) { else => unreachable, 1 => ret_tracking[0], 2 => .init(.{ .register_pair = .{ @@ -181427,97 +185418,96 @@ fn resolveCallingConventionValues( } // Input params - for (param_types, result.args) |ty, *arg| { + params: for (param_types, result.args) |ty, *arg| { assert(ty.hasRuntimeBitsIgnoreComptime(zcu)); result.air_arg_count += 1; switch (cc) { .x86_64_sysv => {}, .x86_64_win => { - param_int_reg_i = @max(param_int_reg_i, param_sse_reg_i); - param_sse_reg_i = param_int_reg_i; + param_gpr_index = @max(param_gpr_index, param_sse_index); + param_sse_index = param_gpr_index; }, else => unreachable, } var arg_mcv: [4]MCValue = undefined; - var arg_mcv_i: usize = 0; + var arg_mcv_len: u32 = 0; const classes = switch (cc) { - .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .arg), .none), - .x86_64_win => &.{abi.classifyWindows(ty, zcu)}, + .x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .arg), .none), + .x86_64_win => &.{abi.classifyWindows(ty, zcu, cg.target)}, else => unreachable, }; classes: for (classes) |class| switch (class) { .integer => { - const param_int_regs = abi.getCAbiIntParamRegs(cc); - if (param_int_reg_i >= param_int_regs.len) break; - - const param_int_reg = - registerAlias(param_int_regs[param_int_reg_i], @intCast(@min(ty.abiSize(zcu), 8))); - param_int_reg_i += 1; - - arg_mcv[arg_mcv_i] = .{ .register = param_int_reg }; - arg_mcv_i += 1; + 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_len += 1; + param_gpr_index += 1; }, .sse, .float, .float_combine => { - const param_sse_regs = abi.getCAbiSseParamRegs(cc, self.target); const abi_size: u32 = @intCast(ty.abiSize(zcu)); - const reg_size = @min(abi_size, self.vectorSize(.float)); + const reg_size = @min(abi_size, cg.vectorSize(.float)); var byte_offset: u32 = 0; while (byte_offset < abi_size) : (byte_offset += reg_size) { - if (param_sse_reg_i >= param_sse_regs.len) break :classes; + if (param_sse_index >= param_sse.len) break :classes; - const param_sse_reg = registerAlias(param_sse_regs[param_sse_reg_i], reg_size); - param_sse_reg_i += 1; + const param_sse_reg = registerAlias(param_sse[param_sse_index], reg_size); + param_sse_index += 1; - arg_mcv[arg_mcv_i] = .{ .register = param_sse_reg }; - arg_mcv_i += 1; + arg_mcv[arg_mcv_len] = .{ .register = param_sse_reg }; + arg_mcv_len += 1; } }, - .sseup => assert(arg_mcv[arg_mcv_i - 1].register.isClass(.sse)), - .x87, .x87up, .complex_x87, .memory, .win_i128 => switch (cc) { + .sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)), + .x87, .x87up, .memory, .win_i128 => switch (cc) { .x86_64_sysv => switch (class) { - .x87, .x87up, .complex_x87, .memory => break, + .x87, .x87up, .memory => break, else => unreachable, }, .x86_64_win => if (ty.abiSize(zcu) > 8) { - const param_int_reg = abi.getCAbiIntParamRegs(cc)[param_int_reg_i].to64(); - param_int_reg_i += 1; - - arg_mcv[arg_mcv_i] = .{ .indirect = .{ .reg = param_int_reg } }; - arg_mcv_i += 1; + 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, else => unreachable, }, .none => unreachable, .integer_per_element => { - const param_int_regs_len: u32 = - @intCast(abi.getCAbiIntParamRegs(cc).len); - const remaining_param_int_regs: u3 = - @intCast(param_int_regs_len - param_int_reg_i); - param_int_reg_i = param_int_regs_len; + const remaining_param_gpr_len: u3 = @intCast(param_gpr.len - param_gpr_index); + param_gpr_index = @intCast(param_gpr.len); const frame_elem_align = 8; - const frame_elems_len = ty.vectorLen(zcu) - remaining_param_int_regs; - const frame_elem_size = std.mem.alignForward( - u64, - ty.childType(zcu).abiSize(zcu), - frame_elem_align, - ); + 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); - result.stack_byte_count = - std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align); - arg_mcv[arg_mcv_i] = .{ .elementwise_args = .{ - .regs = remaining_param_int_regs, + 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), .frame_index = stack_frame_base, } }; - arg_mcv_i += 1; + arg_mcv_len += 1; result.stack_byte_count += frame_size; }, } else { - arg.* = switch (arg_mcv_i) { + arg.* = switch (arg_mcv_len) { else => unreachable, 1 => arg_mcv[0], 2 => .{ .register_pair = .{ @@ -181548,17 +185538,17 @@ fn resolveCallingConventionValues( } }; result.stack_byte_count += @intCast(ty.abiSize(zcu)); } - assert(param_int_reg_i <= 6); - result.gp_count = param_int_reg_i; - assert(param_sse_reg_i <= 16); - result.fp_count = param_sse_reg_i; + assert(param_gpr_index <= 6); + result.gp_count = param_gpr_index; + assert(param_sse_index <= 16); + result.fp_count = param_sse_index; }, .auto => { - result.stack_align = abi.zigcc.stack_align orelse .fromByteUnits(self.vectorSize(.float)); + result.stack_align = abi.zigcc.stack_align orelse .fromByteUnits(cg.vectorSize(.float)); var param_gpr = abi.getCAbiIntParamRegs(cc); var param_x87 = abi.getCAbiX87ParamRegs(cc); - var param_sse = abi.getCAbiSseParamRegs(cc, self.target); + var param_sse = abi.getCAbiSseParamRegs(cc, cg.target); if (zcu.comp.config.any_error_tracing) { result.err_ret_trace_reg = param_gpr[param_gpr.len - 1]; @@ -181573,8 +185563,8 @@ fn resolveCallingConventionValues( 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 (self.regClassForType(ret_ty)) { - .general_purpose, .gphi => if (ret_size <= @as(u4, switch (self.target.cpu.arch) { + 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, @@ -181584,7 +185574,7 @@ fn resolveCallingConventionValues( 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 <= self.vectorSize(.float)) break :return_value .init(.{ + .sse => if (ret_size <= cg.vectorSize(.float)) break :return_value .init(.{ .register = registerAlias(abi.getCAbiSseReturnRegs(cc)[0], @max(ret_size, 16)), }), }; @@ -181604,8 +185594,8 @@ fn resolveCallingConventionValues( } result.air_arg_count += 1; const param_size: u31 = @intCast(param_ty.abiSize(zcu)); - if (abi.zigcc.params_in_regs) switch (self.regClassForType(param_ty)) { - .general_purpose, .gphi => if (param_gpr.len >= 1 and param_size <= @as(u4, switch (self.target.cpu.arch) { + 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, @@ -181624,7 +185614,7 @@ fn resolveCallingConventionValues( param_x87 = param_x87[1..]; continue; }, - .sse => if (param_sse.len >= 1 and param_size <= self.vectorSize(.float)) { + .sse => if (param_sse.len >= 1 and param_size <= cg.vectorSize(.float)) { arg.* = .{ .register = registerAlias(param_sse[0], @max(param_size, 16)), }; @@ -181642,27 +185632,27 @@ fn resolveCallingConventionValues( result.stack_byte_count += param_size; } }, - else => return self.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}), + else => return cg.fail("TODO implement function parameters and return values for {} on x86_64", .{cc}), } result.stack_byte_count = @intCast(result.stack_align.forward(result.stack_byte_count)); return result; } -fn fail(self: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } { +fn fail(cg: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMemory, CodegenFail } { @branchHint(.cold); - const zcu = self.pt.zcu; - switch (self.owner) { + const zcu = cg.pt.zcu; + switch (cg.owner) { .nav_index => |i| return zcu.codegenFail(i, format, args), .lazy_sym => |s| return zcu.codegenFailType(s.ty, format, args), } return error.CodegenFail; } -fn failMsg(self: *CodeGen, msg: *Zcu.ErrorMsg) error{ OutOfMemory, CodegenFail } { +fn failMsg(cg: *CodeGen, msg: *Zcu.ErrorMsg) error{ OutOfMemory, CodegenFail } { @branchHint(.cold); - const zcu = self.pt.zcu; - switch (self.owner) { + const zcu = cg.pt.zcu; + switch (cg.owner) { .nav_index => |i| return zcu.codegenFailMsg(i, msg), .lazy_sym => |s| return zcu.codegenFailTypeMsg(s.ty, msg), } @@ -182127,6 +186117,7 @@ const Temp = struct { .register_mask, .memory, .indirect, + .indirect_load_frame, .lea_frame, .load_nav, .lea_nav, @@ -182200,7 +186191,7 @@ const Temp = struct { switch (temp_tracking.short) { else => {}, .register => |reg| { - try cg.freeValue(temp_tracking.long); + try cg.freeValue(temp_tracking.long, .{}); temp_tracking.* = .init(.{ .register_offset = .{ .reg = reg, .off = off, @@ -182208,7 +186199,7 @@ const Temp = struct { return; }, .register_offset => |reg_off| { - try cg.freeValue(temp_tracking.long); + try cg.freeValue(temp_tracking.long, .{}); temp_tracking.* = .init(.{ .register_offset = .{ .reg = reg_off.reg, .off = reg_off.off + off, @@ -182598,6 +186589,7 @@ const Temp = struct { .register_quadruple, .register_overflow, .register_mask, + .indirect_load_frame, .elementwise_args, .reserved_frame, .air_ref, @@ -182675,7 +186667,7 @@ const Temp = struct { .register_quadruple, => |val_regs| for (val_regs) |val_reg| { try ptr.loadReg(val_ty, val_reg, cg); - try ptr.toOffset(@divExact(val_reg.bitSize(), 8), cg); + try ptr.toOffset(@intCast(@divExact(val_reg.size().bitSize(cg.target), 8)), cg); while (try ptr.toLea(cg)) {} }, .register_offset => |val_reg_off| switch (val_reg_off.off) { @@ -182820,7 +186812,7 @@ const Temp = struct { var disp = opts.disp; for (val_regs) |val_reg| { try src.readReg(disp, val_ty, val_reg, cg); - disp += @divExact(val_reg.bitSize(), 8); + disp += @intCast(@divExact(val_reg.size().bitSize(cg.target), 8)); } }, .register_offset => |val_reg_off| switch (val_reg_off.off) { @@ -182950,25 +186942,59 @@ 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 = .fromBitSize(@min(8 * dst_ty.abiSize(cg.pt.zcu), dst_reg.bitSize())), + .size = cg.memSize(dst_ty), })); } fn storeRegs(ptr: *Temp, src_ty: Type, src_regs: []const Register, cg: *CodeGen) InnerError!void { + const zcu = cg.pt.zcu; + 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)); - for (src_regs) |src_reg| { + for (src_regs, 0..) |src_reg, part_index| { + const part_ty: Type = if (src_regs.len == 1) + src_ty + else if (cg.intInfo(src_ty)) |int_info| part_ty: { + assert(src_regs.len == std.math.divCeil(u16, int_info.bits, 64) catch unreachable); + break :part_ty .u64; + } else part_ty: switch (ip.indexToKey(src_ty.toIntern())) { + else => std.debug.panic("{s}: {}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }), + .ptr_type => |ptr_info| { + assert(ptr_info.flags.size == .slice); + assert(src_regs.len == 2); + 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)); + }, + .opt_type => |opt_child| switch (ip.indexToKey(opt_child)) { + else => std.debug.panic("{s}: {}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }), + .ptr_type => |ptr_info| { + assert(ptr_info.flags.size == .slice); + assert(src_regs.len == 2); + break :part_ty .usize; + }, + }, + .struct_type => { + assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable); + break :part_ty .u64; + }, + }; + const part_size: u31 = @intCast(part_ty.abiSize(zcu)); const src_rc = src_reg.class(); - const part_bit_size = @min(8 * src_abi_size, src_reg.bitSize()); - const part_size = @divExact(part_bit_size, 8); + const part_bit_size = switch (src_rc) { + else => 8 * part_size, + .x87 => part_ty.bitSize(zcu), + }; if (src_rc == .x87 or std.math.isPowerOfTwo(part_size)) { // hack around linker relocation bugs switch (ptr.tracking(cg).short) { else => {}, .lea_nav, .lea_uav, .lea_lazy_sym => while (try ptr.toRegClass(false, .general_purpose, cg)) {}, } - const strat = try cg.moveStrategy(src_ty, src_rc, false); + const strat = try cg.moveStrategy(part_ty, src_rc, false); try strat.write(cg, try ptr.tracking(cg).short.deref().mem(cg, .{ .size = .fromBitSize(part_bit_size), .disp = part_disp, @@ -182979,7 +187005,7 @@ const Temp = struct { .size = frame_size, .alignment = .fromNonzeroByteUnits(frame_size), })); - const strat = try cg.moveStrategy(src_ty, src_rc, true); + const strat = try cg.moveStrategy(part_ty, src_rc, true); try strat.write(cg, .{ .base = .{ .frame = frame_index }, .mod = .{ .rm = .{ .size = .fromSize(frame_size) } }, @@ -183001,7 +187027,7 @@ const Temp = struct { 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); try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{ - .size = .fromBitSize(@min(8 * dst_ty.abiSize(cg.pt.zcu), dst_reg.bitSize())), + .size = cg.memSize(dst_ty), .disp = disp, })); } @@ -183012,7 +187038,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 = .fromBitSize(@min(8 * src_abi_size, src_reg.bitSize())), + .size = cg.memSize(src_ty), .disp = disp, }), registerAlias(src_reg, src_abi_size)); } else { @@ -183050,14 +187076,14 @@ 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, .complex_x87, .none, .win_i128, .integer_per_element => unreachable, + .sseup, .x87up, .none, .win_i128, .integer_per_element => 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, .complex_x87, .none, .win_i128, .integer_per_element => unreachable, + .sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable, }; try dst.writeReg(part_disp, switch (class) { .integer => .u64, @@ -183070,7 +187096,7 @@ const Temp = struct { .x87 => .f80, .float => .f32, .float_combine => .vector_2_f32, - .sseup, .x87up, .complex_x87, .memory, .none, .win_i128, .integer_per_element => unreachable, + .sseup, .x87up, .memory, .none, .win_i128, .integer_per_element => unreachable, }, src_reg, cg); part_disp += part_size; remaining_abi_size -= part_size; @@ -186718,12 +190744,12 @@ const Temp = struct { .{ ._, ._, .div, .src1q, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } }, .none, } }, }, @@ -186741,18 +190767,46 @@ const Temp = struct { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, .patterns = &.{ .{ .src = .{ - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 0 } }, - .{ .to_param_gpr_pair = .{ .cc = .ccc, .at = 2 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, + .{ .to_param_gpr_pair = .{ .cc = .ccc, .after = 2, .at = 2 } }, .none, } }, }, @@ -186770,11 +190824,39 @@ const Temp = struct { .unused, .unused, }, - .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .at = 0 } }, .unused }, + .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, .each = .{ .once = &.{ .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } }, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, + .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, + .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", null, null, null }, .src_constraints = .{ @@ -186787,10 +190869,10 @@ const Temp = struct { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } }, .unused, .unused, @@ -186820,10 +190902,10 @@ const Temp = struct { }, .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } }, .unused, .unused, @@ -187172,7 +191254,7 @@ const Temp = struct { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, @@ -187184,12 +191266,12 @@ const Temp = struct { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, - .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -187210,7 +191292,115 @@ const Temp = struct { .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, }, .{ - .required_features = .{ .@"64bit", null, null, null }, + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, + .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, + .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__divti3" } }, + .{ .type = .i128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .sysv64, .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, @@ -187222,12 +191412,12 @@ const Temp = struct { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } }, - .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .at = 0 } } }, + .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, .unused, .unused, .unused, @@ -187247,6 +191437,114 @@ const Temp = struct { .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } }, + .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } }, + .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, + }, .{ + .required_cc_abi = .win64, + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, + .any, + }, + .patterns = &.{ + .{ .src = .{ .to_mem, .to_mem, .none } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .extern_func = "__udivti3" } }, + .{ .type = .u128, .kind = .{ .ret_sse = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{ .mem, .unused }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .each = .{ .once = &.{ + .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, + .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, + .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, + .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, + .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, + .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, + } }, }, .{ .required_features = .{ .@"64bit", null, null, null }, .src_constraints = .{ @@ -187260,10 +191558,10 @@ const Temp = struct { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__divei4" } }, .unused, .unused, @@ -187296,10 +191594,10 @@ const Temp = struct { .call_frame = .{ .alignment = .@"16" }, .extra_temps = .{ .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 0 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 1 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 2 } } }, - .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .at = 3 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 0, .at = 0 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 1, .at = 1 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 2, .at = 2 } } }, + .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .after = 3, .at = 3 } } }, .{ .type = .usize, .kind = .{ .extern_func = "__udivei4" } }, .unused, .unused, @@ -187337,14 +191635,21 @@ const Temp = struct { if (op_temp.tracking(cg).short != .dead) try op_temp.die(cg); if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; if (cg.reused_operands.isSet(op_index)) continue; - try cg.processDeath(op_ref.toIndexAllowNone() orelse continue); + try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{}); } if (cg.liveness.isUnused(inst)) try temp.die(cg) else { switch (temp.unwrap(cg)) { .ref, .err_ret_trace => { const temp_mcv = temp.tracking(cg).short; const result = result: switch (temp_mcv) { - .none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable, + .none, + .unreach, + .dead, + .indirect_load_frame, + .elementwise_args, + .reserved_frame, + .air_ref, + => unreachable, .undef, .immediate, .lea_frame => temp_mcv, .eflags, .register, @@ -187386,14 +191691,14 @@ const Temp = struct { if (op_temp.index != temp.index) continue; if (tomb_bits & @as(Air.Liveness.Bpi, 1) << @intCast(op_index) == 0) continue; if (cg.reused_operands.isSet(op_index)) continue; - try cg.processDeath(op_ref.toIndexAllowNone() orelse continue); + try cg.processDeath(op_ref.toIndexAllowNone() orelse continue, .{}); } } fn die(temp: Temp, cg: *CodeGen) InnerError!void { switch (temp.unwrap(cg)) { .ref, .err_ret_trace => {}, - .temp => |temp_index| try temp_index.tracking(cg).die(cg, temp_index.toIndex()), + .temp => |temp_index| try temp_index.tracking(cg).die(cg, temp_index.toIndex(), .{}), } } @@ -187779,6 +192084,8 @@ const Select = struct { } const Case = struct { + required_abi: enum { any, gnu, msvc } = .any, + required_cc_abi: enum { any, sysv64, win64 } = .any, required_features: [4]?std.Target.x86.Feature = @splat(null), src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any), dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any), @@ -188151,6 +192458,7 @@ const Select = struct { to_reg_pair: [2]Register, to_param_gpr: TempSpec.Kind.CallConvRegSpec, to_param_gpr_pair: TempSpec.Kind.CallConvRegSpec, + to_param_sse: TempSpec.Kind.CallConvRegSpec, to_ret_gpr: TempSpec.Kind.CallConvRegSpec, to_ret_gpr_pair: TempSpec.Kind.CallConvRegSpec, mem, @@ -188238,7 +192546,7 @@ const Select = struct { .mem => temp.tracking(cg).short.isMemory(), .to_mem, .to_mut_mem => true, .mut_mem => temp.isMut(cg) and temp.tracking(cg).short.isMemory(), - .to_reg, .to_reg_pair, .to_param_gpr, .to_param_gpr_pair, .to_ret_gpr, .to_ret_gpr_pair => true, + .to_reg, .to_reg_pair, .to_param_gpr, .to_param_gpr_pair, .to_param_sse, .to_ret_gpr, .to_ret_gpr_pair => true, .gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { .register => |reg| reg.isClass(.general_purpose), .register_offset => |reg_off| reg_off.reg.isClass(.general_purpose) and reg_off.off == 0, @@ -188343,10 +192651,11 @@ const Select = struct { .mut_mem, .to_mut_mem => try temp.toBase(true, cg), .to_reg => |reg| try temp.toReg(reg, cg), .to_reg_pair => |regs| try temp.toRegPair(regs, cg), - .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at], cg), - .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*, cg), - .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at], cg), - .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*, cg), + .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)], cg), + .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*, cg), + .to_param_sse => |param_spec| try temp.toReg(abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)], cg), + .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)], cg), + .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*, cg), .gpr, .immut_gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), .to_gphi => try temp.toRegClass(false, .gphi, cg), @@ -188381,8 +192690,10 @@ const Select = struct { reg_pair: [2]Register, param_gpr: CallConvRegSpec, param_gpr_pair: CallConvRegSpec, + param_sse: CallConvRegSpec, ret_gpr: CallConvRegSpec, ret_gpr_pair: CallConvRegSpec, + ret_sse: CallConvRegSpec, rc: Register.Class, rc_pair: Register.Class, mut_rc: struct { ref: Select.Operand.Ref, rc: Register.Class }, @@ -188422,6 +192733,7 @@ const Select = struct { const CallConvRegSpec = struct { cc: Case.CallConv, + after: u2, at: u2, fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag { @@ -188431,6 +192743,14 @@ const Select = struct { .zigcc => .auto, }; } + + fn index(spec: CallConvRegSpec, cg: *const CodeGen) u2 { + return switch (spec.tag(cg)) { + .auto, .x86_64_sysv => spec.after, + .x86_64_win => spec.at, + else => unreachable, + }; + } }; fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock { @@ -188439,10 +192759,12 @@ const Select = struct { else => return reg_locks, .reg => |reg| .{ reg, .none }, .reg_pair => |regs| regs, - .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..1].* ++ .{.none}, - .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*, - .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..1].* ++ .{.none}, - .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*, + .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..1].* ++ .{.none}, + .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*, + .param_sse => |param_spec| abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)..][0..1].* ++ .{.none}, + .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none}, + .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*, + .ret_sse => |ret_spec| abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..1].* ++ .{.none}, }; for (regs, ®_locks) |reg, *reg_lock| { if (reg == .none) continue; @@ -188476,16 +192798,22 @@ const Select = struct { .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, .reg_pair => |regs| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true }, .param_gpr => |param_spec| .{ try cg.tempInit(spec.type, .{ - .register = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at], + .register = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)], }), true }, .param_gpr_pair => |param_spec| .{ try cg.tempInit(spec.type, .{ - .register_pair = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.at..][0..2].*, + .register_pair = abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index(cg)..][0..2].*, + }), true }, + .param_sse => |param_spec| .{ try cg.tempInit(spec.type, .{ + .register = abi.getCAbiSseParamRegs(param_spec.tag(cg), cg.target)[param_spec.index(cg)], }), true }, .ret_gpr => |ret_spec| .{ try cg.tempInit(spec.type, .{ - .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at], + .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)], }), true }, .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{ - .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.at..][0..2].*, + .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)..][0..2].*, + }), true }, + .ret_sse => |ret_spec| .{ try cg.tempInit(spec.type, .{ + .register = abi.getCAbiSseReturnRegs(ret_spec.tag(cg))[ret_spec.index(cg)], }), true }, .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true }, .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true }, @@ -188842,7 +193170,17 @@ const Select = struct { .storage = .{ .elems = elems }, } }))), true }; }, - .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, + .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ + .index = frame_index, + .off = switch (frame_index) { + .call_frame => switch (cg.target.cCallingConvention().?) { + .x86_64_sysv => 0, + .x86_64_win => win64_shadow_space, + else => unreachable, + }, + else => 0, + }, + } }), true }, .lazy_sym => |lazy_symbol_spec| { const ip = &pt.zcu.intern_pool; const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s); @@ -188997,6 +193335,7 @@ const Select = struct { const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" }; const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" }; const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; + const sub_dst0_elem_size: Adjust = .{ .sign = .neg, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" }; const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" }; const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" }; @@ -189287,7 +193626,11 @@ const Select = struct { const tmp0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0t } }; const tmp0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0x } }; const tmp0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0y } }; + const tmp0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 1 }; + const tmp0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 1 }; const tmp0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 1 }; + const tmp0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0w }, .imm = 2 }; + const tmp0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0d }, .imm = 2 }; const tmp0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp0q }, .imm = 2 }; const tmp1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1l } }; @@ -189301,7 +193644,11 @@ const Select = struct { const tmp1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1t } }; const tmp1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1x } }; const tmp1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1y } }; + const tmp1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 1 }; + const tmp1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 1 }; const tmp1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 1 }; + const tmp1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1w }, .imm = 2 }; + const tmp1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1d }, .imm = 2 }; const tmp1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp1q }, .imm = 2 }; const tmp2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2l } }; @@ -189315,7 +193662,11 @@ const Select = struct { const tmp2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2t } }; const tmp2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2x } }; const tmp2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2y } }; + const tmp2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 1 }; + const tmp2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 1 }; const tmp2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 1 }; + const tmp2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2w }, .imm = 2 }; + const tmp2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2d }, .imm = 2 }; const tmp2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp2q }, .imm = 2 }; const tmp3l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3l } }; @@ -189329,7 +193680,11 @@ const Select = struct { const tmp3t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3t } }; const tmp3x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3x } }; const tmp3y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3y } }; + const tmp3w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 1 }; + const tmp3d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 1 }; const tmp3q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 1 }; + const tmp3w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3w }, .imm = 2 }; + const tmp3d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3d }, .imm = 2 }; const tmp3q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp3q }, .imm = 2 }; const tmp4l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4l } }; @@ -189343,7 +193698,11 @@ const Select = struct { const tmp4t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4t } }; const tmp4x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4x } }; const tmp4y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4y } }; + const tmp4w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 1 }; + const tmp4d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 1 }; const tmp4q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 1 }; + const tmp4w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4w }, .imm = 2 }; + const tmp4d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4d }, .imm = 2 }; const tmp4q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp4q }, .imm = 2 }; const tmp5l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5l } }; @@ -189357,7 +193716,11 @@ const Select = struct { const tmp5t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5t } }; const tmp5x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5x } }; const tmp5y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5y } }; + const tmp5w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 1 }; + const tmp5d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 1 }; const tmp5q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 1 }; + const tmp5w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5w }, .imm = 2 }; + const tmp5d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5d }, .imm = 2 }; const tmp5q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp5q }, .imm = 2 }; const tmp6l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6l } }; @@ -189371,7 +193734,11 @@ const Select = struct { const tmp6t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6t } }; const tmp6x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6x } }; const tmp6y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6y } }; + const tmp6w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 1 }; + const tmp6d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 1 }; const tmp6q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 1 }; + const tmp6w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6w }, .imm = 2 }; + const tmp6d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6d }, .imm = 2 }; const tmp6q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp6q }, .imm = 2 }; const tmp7l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7l } }; @@ -189385,7 +193752,11 @@ const Select = struct { const tmp7t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7t } }; const tmp7x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7x } }; const tmp7y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7y } }; + const tmp7w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 1 }; + const tmp7d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 1 }; const tmp7q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 1 }; + const tmp7w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7w }, .imm = 2 }; + const tmp7d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7d }, .imm = 2 }; const tmp7q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp7q }, .imm = 2 }; const tmp8l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8l } }; @@ -189399,7 +193770,11 @@ const Select = struct { const tmp8t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8t } }; const tmp8x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8x } }; const tmp8y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8y } }; + const tmp8w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 1 }; + const tmp8d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 1 }; const tmp8q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 1 }; + const tmp8w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8w }, .imm = 2 }; + const tmp8d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8d }, .imm = 2 }; const tmp8q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp8q }, .imm = 2 }; const tmp9l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9l } }; @@ -189413,7 +193788,11 @@ const Select = struct { const tmp9t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9t } }; const tmp9x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9x } }; const tmp9y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9y } }; + const tmp9w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 1 }; + const tmp9d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 1 }; const tmp9q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 1 }; + const tmp9w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9w }, .imm = 2 }; + const tmp9d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9d }, .imm = 2 }; const tmp9q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp9q }, .imm = 2 }; const tmp10l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10l } }; @@ -189427,7 +193806,11 @@ const Select = struct { const tmp10t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10t } }; const tmp10x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10x } }; const tmp10y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10y } }; + const tmp10w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 1 }; + const tmp10d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 1 }; const tmp10q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 1 }; + const tmp10w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10w }, .imm = 2 }; + const tmp10d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10d }, .imm = 2 }; const tmp10q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .tmp10q }, .imm = 2 }; const dst0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0l } }; @@ -189441,7 +193824,11 @@ const Select = struct { const dst0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0t } }; const dst0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0x } }; const dst0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0y } }; + const dst0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 1 }; + const dst0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 1 }; const dst0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 1 }; + const dst0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0w }, .imm = 2 }; + const dst0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0d }, .imm = 2 }; const dst0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst0q }, .imm = 2 }; const dst1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1l } }; @@ -189455,7 +193842,11 @@ const Select = struct { const dst1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1t } }; const dst1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1x } }; const dst1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1y } }; + const dst1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 1 }; + const dst1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 1 }; const dst1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 1 }; + const dst1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1w }, .imm = 2 }; + const dst1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1d }, .imm = 2 }; const dst1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .dst1q }, .imm = 2 }; const src0l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0l } }; @@ -189469,7 +193860,11 @@ const Select = struct { const src0t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0t } }; const src0x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0x } }; const src0y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0y } }; + const src0w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 1 }; + const src0d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 1 }; const src0q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 1 }; + const src0w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0w }, .imm = 2 }; + const src0d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0d }, .imm = 2 }; const src0q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src0q }, .imm = 2 }; const src1l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1l } }; @@ -189483,7 +193878,11 @@ const Select = struct { const src1t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1t } }; const src1x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1x } }; const src1y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1y } }; + const src1w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 1 }; + const src1d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 1 }; const src1q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 1 }; + const src1w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1w }, .imm = 2 }; + const src1d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1d }, .imm = 2 }; const src1q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src1q }, .imm = 2 }; const src2l: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2l } }; @@ -189497,7 +193896,11 @@ const Select = struct { const src2t: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2t } }; const src2x: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2x } }; const src2y: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2y } }; + const src2w0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 1 }; + const src2d0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 1 }; const src2q0: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 1 }; + const src2w1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2w }, .imm = 2 }; + const src2d1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2d }, .imm = 2 }; const src2q1: Select.Operand = .{ .flags = .{ .tag = .ref, .base = .src2q }, .imm = 2 }; fn si(imm: i32) Select.Operand { @@ -189956,6 +194359,22 @@ fn select( ) Select.Error!void { @setEvalBranchQuota(33_500); cases: for (cases) |case| { + switch (case.required_abi) { + .any => {}, + .gnu => if (switch (cg.target.abi) { + .none, .msvc, .itanium => cg.target.os.tag == .windows, + else => false, + }) continue :cases, + .msvc => if (switch (cg.target.abi) { + .none, .msvc, .itanium => cg.target.os.tag != .windows, + else => true, + }) continue :cases, + } + switch (case.required_cc_abi) { + .any => {}, + .sysv64 => if (cg.target.cCallingConvention().? != .x86_64_sysv) continue :cases, + .win64 => if (cg.target.cCallingConvention().? != .x86_64_win) continue :cases, + } for (case.required_features) |required_feature| if (required_feature) |feature| if (!cg.hasFeature(feature)) continue :cases; for (case.src_constraints[0..src_temps.len], src_temps) |src_constraint, src_temp| if (!src_constraint.accepts(src_temp.typeOf(cg), cg)) continue :cases; for (case.dst_constraints[0..dst_temps.len], dst_tys) |dst_constraint, dst_ty| if (!dst_constraint.accepts(dst_ty, cg)) continue :cases; @@ -189972,7 +194391,11 @@ fn select( 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.*, case.call_frame.size); + stack_frame_size.* = @max(stack_frame_size.*, switch (cg.target.cCallingConvention().?) { + .x86_64_sysv => case.call_frame.size, + .x86_64_win => win64_shadow_space + case.call_frame.size, + else => unreachable, + }); const stack_frame_align = &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; stack_frame_align.* = stack_frame_align.max(case.call_frame.alignment); diff --git a/src/arch/x86_64/Emit.zig b/src/arch/x86_64/Emit.zig index 8904dada8ca1..7ba8d460de2b 100644 --- a/src/arch/x86_64/Emit.zig +++ b/src/arch/x86_64/Emit.zig @@ -107,7 +107,7 @@ pub fn emitMir(emit: *Emit) Error!void { nav, emit.lower.target, )) { - .mcv => |mcv| mcv.lea_symbol, + .sym_index => |sym_index| sym_index, .fail => |em| { assert(emit.lower.err_msg == null); emit.lower.err_msg = em; @@ -151,7 +151,7 @@ pub fn emitMir(emit: *Emit) Error!void { Type.fromInterned(uav.orig_ty).ptrAlignment(emit.pt.zcu), emit.lower.src_loc, )) { - .mcv => |mcv| mcv.load_symbol, + .sym_index => |sym_index| sym_index, .fail => |em| { assert(emit.lower.err_msg == null); emit.lower.err_msg = em; @@ -186,7 +186,7 @@ pub fn emitMir(emit: *Emit) Error!void { else if (emit.bin_file.cast(.macho)) |macho_file| try macho_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null) else if (emit.bin_file.cast(.coff)) |coff_file| - link.File.Coff.global_symbol_bit | try coff_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null) + try coff_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, "compiler_rt") else return emit.fail("external symbols unimplemented for {s}", .{@tagName(emit.bin_file.tag)}), .is_extern = true, @@ -548,10 +548,7 @@ pub fn emitMir(emit: *Emit) Error!void { => return emit.fail("unable to codegen: {s}", .{@errorName(err)}), else => |e| return e, }) { - .mcv => |mcv| switch (mcv) { - else => unreachable, - .load_direct, .load_symbol => |sym_index| sym_index, - }, + .sym_index => |sym_index| sym_index, .fail => |em| { assert(emit.lower.err_msg == null); emit.lower.err_msg = em; @@ -564,10 +561,7 @@ pub fn emitMir(emit: *Emit) Error!void { Type.fromInterned(uav.orig_ty).ptrAlignment(emit.pt.zcu), emit.lower.src_loc, )) { - .mcv => |mcv| switch (mcv) { - else => unreachable, - .load_direct, .load_symbol => |sym_index| sym_index, - }, + .sym_index => |sym_index| sym_index, .fail => |em| { assert(emit.lower.err_msg == null); emit.lower.err_msg = em; diff --git a/src/arch/x86_64/Encoding.zig b/src/arch/x86_64/Encoding.zig index 8c019d1882a4..1b7d5ed3d417 100644 --- a/src/arch/x86_64/Encoding.zig +++ b/src/arch/x86_64/Encoding.zig @@ -598,7 +598,7 @@ pub const Op = enum { .rax => .rax, .cl => .cl, .dx => .dx, - else => switch (reg.bitSize()) { + else => switch (reg.size().bitSize(target)) { 8 => .r8, 16 => .r16, 32 => .r32, @@ -615,7 +615,7 @@ pub const Op = enum { .mmx => .mm, .sse => switch (reg) { .xmm0 => .xmm0, - else => switch (reg.bitSize()) { + else => switch (reg.size().bitSize(target)) { 128 => .xmm, 256 => .ymm, else => unreachable, diff --git a/src/arch/x86_64/Mir.zig b/src/arch/x86_64/Mir.zig index 70f809068552..bc99d871ac84 100644 --- a/src/arch/x86_64/Mir.zig +++ b/src/arch/x86_64/Mir.zig @@ -12,6 +12,8 @@ extra: []const u32, string_bytes: []const u8, locals: []const Local, table: []const Inst.Index, +/// Optional data which, when present, can be used to accelerate encoding speed. +memoized_encodings: []const u0 = &.{}, frame_locs: std.MultiArrayList(FrameLoc).Slice, pub const Inst = struct { @@ -1963,6 +1965,7 @@ pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void { gpa.free(mir.string_bytes); gpa.free(mir.locals); gpa.free(mir.table); + gpa.free(mir.memoized_encodings); mir.frame_locs.deinit(gpa); mir.* = undefined; } diff --git a/src/arch/x86_64/abi.zig b/src/arch/x86_64/abi.zig index 43cb4003bee7..041eb1632d3b 100644 --- a/src/arch/x86_64/abi.zig +++ b/src/arch/x86_64/abi.zig @@ -1,20 +1,86 @@ pub const Class = enum { + /// INTEGER: This class consists of integral types that fit into one of the general + /// purpose registers. integer, + /// SSE: The class consists of types that fit into a vector register. sse, + /// SSEUP: The class consists of types that fit into a vector register and can be passed + /// and returned in the upper bytes of it. sseup, + /// X87, X87UP: These classes consist of types that will be returned via the + /// x87 FPU. x87, + /// The 15-bit exponent, 1-bit sign, and 6 bytes of padding of an `f80`. x87up, - complex_x87, - memory, + /// NO_CLASS: This class is used as initializer in the algorithms. It will be used for + /// padding and empty structures and unions. none, + /// MEMORY: This class consists of types that will be passed and returned in mem- + /// ory via the stack. + memory, + /// Win64 passes 128-bit integers as `Class.memory` but returns them as `Class.sse`. win_i128, + /// A `Class.sse` containing one `f32`. 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`. integer_per_element, - fn isX87(class: Class) bool { + 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, + }; + + /// 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 stack: [8]Class = .{ + .memory, .none, .none, .none, + .none, .none, .none, .none, + }; + + pub fn isX87(class: Class) bool { return switch (class) { - .x87, .x87up, .complex_x87 => true, + .x87, .x87up => true, else => false, }; } @@ -44,7 +110,7 @@ pub const Class = enum { } }; -pub fn classifyWindows(ty: Type, zcu: *Zcu) Class { +pub fn classifyWindows(ty: Type, zcu: *Zcu, target: *const std.Target) 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 @@ -53,7 +119,7 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class { // "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." - switch (ty.zigTypeTag(zcu)) { + return switch (ty.zigTypeTag(zcu)) { .pointer, .int, .bool, @@ -70,19 +136,23 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class { .frame, => switch (ty.abiSize(zcu)) { 0 => unreachable, - 1, 2, 4, 8 => return .integer, + 1, 2, 4, 8 => .integer, else => switch (ty.zigTypeTag(zcu)) { - .int => return .win_i128, - .@"struct", .@"union" => if (ty.containerLayout(zcu) == .@"packed") { - return .win_i128; - } else { - return .memory; - }, - else => return .memory, + .int => .win_i128, + .@"struct", .@"union" => if (ty.containerLayout(zcu) == .@"packed") + .win_i128 + else + .memory, + else => .memory, }, }, - .float, .vector => return .sse, + .float => switch (ty.floatBits(target)) { + 16, 32, 64, 128 => .sse, + 80 => .memory, + else => unreachable, + }, + .vector => .sse, .type, .comptime_float, @@ -93,171 +163,109 @@ pub fn classifyWindows(ty: Type, zcu: *Zcu) Class { .@"opaque", .enum_literal, => unreachable, - } + }; } -pub const Context = enum { ret, arg, field, other }; +pub const Context = enum { ret, arg, other }; /// There are a maximum of 8 possible return slots. Returned values are in /// 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 { - const memory_class = [_]Class{ - .memory, .none, .none, .none, - .none, .none, .none, .none, - }; - var result = [1]Class{.none} ** 8; switch (ty.zigTypeTag(zcu)) { .pointer => switch (ty.ptrSize(zcu)) { - .slice => { - result[0] = .integer; - result[1] = .integer; - return result; - }, - else => { - result[0] = .integer; - return result; - }, + .slice => return Class.two_integers, + else => return Class.one_integer, }, .int, .@"enum", .error_set => { const bits = ty.intInfo(zcu).bits; - if (bits <= 64) { - result[0] = .integer; - return result; - } - if (bits <= 128) { - result[0] = .integer; - result[1] = .integer; - return result; - } - if (bits <= 192) { - result[0] = .integer; - result[1] = .integer; - result[2] = .integer; - return result; - } - if (bits <= 256) { - result[0] = .integer; - result[1] = .integer; - result[2] = .integer; - result[3] = .integer; - return result; - } - return memory_class; - }, - .bool, .void, .noreturn => { - result[0] = .integer; - return result; + 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 == .field) { - result[0] = .memory; - } else { - // TODO clang doesn't allow __fp16 as .ret or .arg - result[0] = .sse; - } - return result; - }, - 32 => { - result[0] = .float; - return result; - }, - 64 => { - result[0] = .sse; - return result; - }, - 128 => { - // "Arguments of types __float128, _Decimal128 and __m128 are - // split into two halves. The least significant ones belong - // to class SSE, the most significant one to class SSEUP." - result[0] = .sse; - result[1] = .sseup; - return result; - }, - 80 => { - // "The 64-bit mantissa of arguments of type long double - // belongs to classX87, the 16-bit exponent plus 6 bytes - // of padding belongs to class X87UP." - result[0] = .x87; - result[1] = .x87up; - return result; + if (ctx == .other) return Class.stack; + // TODO clang doesn't allow __fp16 as .ret or .arg + return Class.f16; }, + 32 => return Class.f32, + 64 => return Class.f64, + // "Arguments of types __float128, _Decimal128 and __m128 are + // split into two halves. The least significant ones belong + // to class SSE, the most significant one to class SSEUP." + 128 => return Class.f128, + // "The 64-bit mantissa of arguments of type long double + // belongs to class X87, the 16-bit exponent plus 6 bytes + // of padding belongs to class X87UP." + 80 => return Class.f80, else => unreachable, }, .vector => { 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 .{ - .integer, .none, .none, .none, - .none, .none, .none, .none, - }; - if (bits <= 64) return .{ - .sse, .none, .none, .none, - .none, .none, .none, .none, - }; - if (ctx == .arg) { - if (bits <= 128) return .{ - .integer_per_element, .none, .none, .none, - .none, .none, .none, .none, - }; - if (bits <= 256 and target.cpu.has(.x86, .avx)) return .{ - .integer_per_element, .none, .none, .none, - .none, .none, .none, .none, - }; - if (bits <= 512 and target.cpu.has(.x86, .avx512f)) return .{ - .integer_per_element, .none, .none, .none, - .none, .none, .none, .none, - }; - } - return memory_class; + 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; + 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; + return Class.stack; } - if (bits <= 64) return .{ + if (bits <= 64 * 1) return .{ .sse, .none, .none, .none, .none, .none, .none, .none, }; - if (bits <= 128) return .{ + if (bits <= 64 * 2) return .{ .sse, .sseup, .none, .none, .none, .none, .none, .none, }; - if (ctx == .arg and !target.cpu.has(.x86, .avx)) return memory_class; - if (bits <= 192) return .{ + 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 <= 256) return .{ + if (bits <= 64 * 4) return .{ .sse, .sseup, .sseup, .sseup, .none, .none, .none, .none, }; - if (ctx == .arg and !target.cpu.has(.x86, .avx512f)) return memory_class; - if (bits <= 320) return .{ + 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 <= 384) return .{ + if (bits <= 64 * 6) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .none, .none, }; - if (bits <= 448) return .{ + if (bits <= 64 * 7) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .none, }; - if (bits <= 512 or (ctx == .ret and bits <= @as(u64, if (target.cpu.has(.x86, .avx512f)) - 2048 + 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)) - 1024 + 64 * 16 else - 512))) return .{ + 64 * 8))) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, }; - return memory_class; + return Class.stack; }, .optional => { if (ty.optionalReprIsPayload(zcu)) { return classifySystemV(ty.optionalChild(zcu), zcu, target, ctx); } - return memory_class; + return Class.stack; }, .@"struct", .@"union" => { // "If the size of an object is larger than eight eightbytes, or @@ -269,15 +277,14 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont .auto => unreachable, .@"extern" => {}, .@"packed" => { - assert(ty_size <= 16); - result[0] = .integer; - if (ty_size > 8) result[1] = .integer; - return result; + if (ty_size <= 8) return Class.one_integer; + if (ty_size <= 16) return Class.two_integers; + unreachable; // frontend should not have allowed this type as extern }, } - if (ty_size > 64) - return memory_class; + if (ty_size > 64) return Class.stack; + var result: [8]Class = @splat(.none); _ = if (zcu.typeToStruct(ty)) |loaded_struct| classifySystemVStruct(&result, 0, loaded_struct, zcu, target) else if (zcu.typeToUnion(ty)) |loaded_union| @@ -290,15 +297,15 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont // "If one of the classes is MEMORY, the whole argument is passed in memory" // "If X87UP is not preceded by X87, the whole argument is passed in memory." for (result, 0..) |class, i| switch (class) { - .memory => return memory_class, - .x87up => if (i == 0 or result[i - 1] != .x87) return memory_class, + .memory => return Class.stack, + .x87up => if (i == 0 or result[i - 1] != .x87) return Class.stack, else => continue, }; // "If the size of the aggregate exceeds two eightbytes and the first eight- // byte isn’t SSE or any other eightbyte isn’t SSEUP, the whole argument // is passed in memory." if (ty_size > 16 and (result[0] != .sse or - std.mem.indexOfNone(Class, result[1..], &.{ .sseup, .none }) != null)) return memory_class; + std.mem.indexOfNone(Class, result[1..], &.{ .sseup, .none }) != null)) return Class.stack; // "If SSEUP is not preceded by SSE or SSEUP, it is converted to SSE." for (&result, 0..) |*item, i| { @@ -311,16 +318,9 @@ pub fn classifySystemV(ty: Type, zcu: *Zcu, target: *const std.Target, ctx: Cont }, .array => { const ty_size = ty.abiSize(zcu); - if (ty_size <= 8) { - result[0] = .integer; - return result; - } - if (ty_size <= 16) { - result[0] = .integer; - result[1] = .integer; - return result; - } - return memory_class; + if (ty_size <= 8) return Class.one_integer; + if (ty_size <= 16) return Class.two_integers; + return Class.stack; }, else => unreachable, } @@ -363,7 +363,7 @@ fn classifySystemVStruct( .@"packed" => {}, } } - const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none); + const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .other), .none); for (result[@intCast(byte_offset / 8)..][0..field_classes.len], field_classes) |*result_class, field_class| result_class.* = result_class.combineSystemV(field_class); byte_offset += field_ty.abiSize(zcu); @@ -406,7 +406,7 @@ fn classifySystemVUnion( .@"packed" => {}, } } - const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .field), .none); + const field_classes = std.mem.sliceTo(&classifySystemV(field_ty, zcu, target, .other), .none); for (result[@intCast(starting_byte_offset / 8)..][0..field_classes.len], field_classes) |*result_class, field_class| result_class.* = result_class.combineSystemV(field_class); } diff --git a/src/arch/x86_64/bits.zig b/src/arch/x86_64/bits.zig index c854af91d2fb..18e7a364cb03 100644 --- a/src/arch/x86_64/bits.zig +++ b/src/arch/x86_64/bits.zig @@ -465,25 +465,25 @@ pub const Register = enum(u8) { return @intCast(@intFromEnum(reg) - base); } - pub fn bitSize(reg: Register) u10 { + pub fn size(reg: Register) Memory.Size { return switch (@intFromEnum(reg)) { // zig fmt: off - @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => 64, - @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => 32, - @intFromEnum(Register.ax) ... @intFromEnum(Register.r15w) => 16, - @intFromEnum(Register.al) ... @intFromEnum(Register.r15b) => 8, - @intFromEnum(Register.ah) ... @intFromEnum(Register.bh) => 8, + @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => .qword, + @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => .dword, + @intFromEnum(Register.ax) ... @intFromEnum(Register.r15w) => .word, + @intFromEnum(Register.al) ... @intFromEnum(Register.r15b) => .byte, + @intFromEnum(Register.ah) ... @intFromEnum(Register.bh) => .byte, - @intFromEnum(Register.zmm0) ... @intFromEnum(Register.zmm15) => 512, - @intFromEnum(Register.ymm0) ... @intFromEnum(Register.ymm15) => 256, - @intFromEnum(Register.xmm0) ... @intFromEnum(Register.xmm15) => 128, - @intFromEnum(Register.mm0) ... @intFromEnum(Register.mm7) => 64, - @intFromEnum(Register.st0) ... @intFromEnum(Register.st7) => 80, + @intFromEnum(Register.zmm0) ... @intFromEnum(Register.zmm15) => .zword, + @intFromEnum(Register.ymm0) ... @intFromEnum(Register.ymm15) => .yword, + @intFromEnum(Register.xmm0) ... @intFromEnum(Register.xmm15) => .xword, + @intFromEnum(Register.mm0) ... @intFromEnum(Register.mm7) => .qword, + @intFromEnum(Register.st0) ... @intFromEnum(Register.st7) => .tbyte, - @intFromEnum(Register.es) ... @intFromEnum(Register.gs) => 16, + @intFromEnum(Register.es) ... @intFromEnum(Register.gs) => .word, - @intFromEnum(Register.cr0) ... @intFromEnum(Register.cr15) => 64, - @intFromEnum(Register.dr0) ... @intFromEnum(Register.dr15) => 64, + @intFromEnum(Register.cr0) ... @intFromEnum(Register.cr15) => .gpr, + @intFromEnum(Register.dr0) ... @intFromEnum(Register.dr15) => .gpr, else => unreachable, // zig fmt: on @@ -549,8 +549,8 @@ pub const Register = enum(u8) { }; } - pub fn toSize(reg: Register, size: Memory.Size, target: *const std.Target) Register { - return switch (size) { + pub fn toSize(reg: Register, new_size: Memory.Size, target: *const std.Target) Register { + return switch (new_size) { .none => unreachable, .ptr => reg.toBitSize(target.ptrBitWidth()), .gpr => switch (target.cpu.arch) { diff --git a/src/codegen.zig b/src/codegen.zig index d1b62e352eea..11b6eedc8683 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -810,7 +810,7 @@ fn lowerUavRef( const uav_align = ip.indexToKey(uav.orig_ty).ptr_type.flags.alignment; switch (try lf.lowerUav(pt, uav_val, uav_align, src_loc)) { - .mcv => {}, + .sym_index => {}, .fail => |em| std.debug.panic("TODO rework lowerUav. internal error: {s}", .{em.msg}), } @@ -920,36 +920,7 @@ pub const LinkerLoad = struct { sym_index: u32, }; -pub const GenResult = union(enum) { - mcv: MCValue, - fail: *ErrorMsg, - - const MCValue = union(enum) { - none, - undef, - /// The bit-width of the immediate may be smaller than `u64`. For example, on 32-bit targets - /// such as ARM, the immediate will never exceed 32-bits. - immediate: u64, - /// Decl with address deferred until the linker allocates everything in virtual memory. - /// Payload is a symbol index. - load_direct: u32, - /// Decl with address deferred until the linker allocates everything in virtual memory. - /// Payload is a symbol index. - lea_direct: u32, - /// Decl referenced via GOT with address deferred until the linker allocates - /// everything in virtual memory. - /// Payload is a symbol index. - load_got: u32, - /// Direct by-address reference to memory location. - memory: u64, - /// Reference to memory location but deferred until linker allocated the Decl in memory. - /// Traditionally, this corresponds to emitting a relocation in a relocatable object file. - load_symbol: u32, - /// Reference to memory location but deferred until linker allocated the Decl in memory. - /// Traditionally, this corresponds to emitting a relocation in a relocatable object file. - lea_symbol: u32, - }; -}; +pub const SymbolResult = union(enum) { sym_index: u32, fail: *ErrorMsg }; pub fn genNavRef( lf: *link.File, @@ -957,7 +928,7 @@ pub fn genNavRef( src_loc: Zcu.LazySrcLoc, nav_index: InternPool.Nav.Index, target: *const std.Target, -) CodeGenError!GenResult { +) CodeGenError!SymbolResult { const zcu = pt.zcu; const ip = &zcu.intern_pool; const nav = ip.getNav(nav_index); @@ -973,7 +944,7 @@ pub fn genNavRef( .internal => { const sym_index = try zo.getOrCreateMetadataForNav(zcu, nav_index); if (is_threadlocal) zo.symbol(sym_index).flags.is_tls = true; - return .{ .mcv = .{ .lea_symbol = sym_index } }; + return .{ .sym_index = sym_index }; }, .strong, .weak => { const sym_index = try elf_file.getGlobalSymbol(nav.name.toSlice(ip), lib_name.toSlice(ip)); @@ -984,7 +955,7 @@ pub fn genNavRef( .link_once => unreachable, } if (is_threadlocal) zo.symbol(sym_index).flags.is_tls = true; - return .{ .mcv = .{ .lea_symbol = sym_index } }; + return .{ .sym_index = sym_index }; }, .link_once => unreachable, } @@ -994,7 +965,7 @@ pub fn genNavRef( .internal => { const sym_index = try zo.getOrCreateMetadataForNav(macho_file, nav_index); if (is_threadlocal) zo.symbols.items[sym_index].flags.tlv = true; - return .{ .mcv = .{ .lea_symbol = sym_index } }; + return .{ .sym_index = sym_index }; }, .strong, .weak => { const sym_index = try macho_file.getGlobalSymbol(nav.name.toSlice(ip), lib_name.toSlice(ip)); @@ -1005,7 +976,7 @@ pub fn genNavRef( .link_once => unreachable, } if (is_threadlocal) zo.symbols.items[sym_index].flags.tlv = true; - return .{ .mcv = .{ .lea_symbol = sym_index } }; + return .{ .sym_index = sym_index }; }, .link_once => unreachable, } @@ -1015,25 +986,55 @@ pub fn genNavRef( .internal => { const atom_index = try coff_file.getOrCreateAtomForNav(nav_index); const sym_index = coff_file.getAtom(atom_index).getSymbolIndex().?; - return .{ .mcv = .{ .lea_symbol = sym_index } }; + return .{ .sym_index = sym_index }; }, .strong, .weak => { const global_index = try coff_file.getGlobalSymbol(nav.name.toSlice(ip), lib_name.toSlice(ip)); try coff_file.need_got_table.put(zcu.gpa, global_index, {}); // needs GOT - return .{ .mcv = .{ .lea_symbol = global_index } }; + return .{ .sym_index = global_index }; }, .link_once => unreachable, } } else if (lf.cast(.plan9)) |p9| { - const atom_index = try p9.seeNav(pt, nav_index); - const atom = p9.getAtom(atom_index); - return .{ .mcv = .{ .memory = atom.getOffsetTableAddress(p9) } }; + return .{ .sym_index = try p9.seeNav(pt, nav_index) }; } else { const msg = try ErrorMsg.create(zcu.gpa, src_loc, "TODO genNavRef for target {}", .{target}); return .{ .fail = msg }; } } +/// deprecated legacy type +pub const GenResult = union(enum) { + mcv: MCValue, + fail: *ErrorMsg, + + const MCValue = union(enum) { + none, + undef, + /// The bit-width of the immediate may be smaller than `u64`. For example, on 32-bit targets + /// such as ARM, the immediate will never exceed 32-bits. + immediate: u64, + /// Decl with address deferred until the linker allocates everything in virtual memory. + /// Payload is a symbol index. + load_direct: u32, + /// Decl with address deferred until the linker allocates everything in virtual memory. + /// Payload is a symbol index. + lea_direct: u32, + /// Decl referenced via GOT with address deferred until the linker allocates + /// everything in virtual memory. + /// Payload is a symbol index. + load_got: u32, + /// Direct by-address reference to memory location. + memory: u64, + /// Reference to memory location but deferred until linker allocated the Decl in memory. + /// Traditionally, this corresponds to emitting a relocation in a relocatable object file. + load_symbol: u32, + /// Reference to memory location but deferred until linker allocated the Decl in memory. + /// Traditionally, this corresponds to emitting a relocation in a relocatable object file. + lea_symbol: u32, + }; +}; + /// deprecated legacy code path pub fn genTypedValue( lf: *link.File, @@ -1042,30 +1043,28 @@ pub fn genTypedValue( val: Value, target: *const std.Target, ) CodeGenError!GenResult { - return switch (try lowerValue(pt, val, target)) { + const res = try lowerValue(pt, val, target); + return switch (res) { .none => .{ .mcv = .none }, .undef => .{ .mcv = .undef }, .immediate => |imm| .{ .mcv = .{ .immediate = imm } }, - .lea_nav => |nav| genNavRef(lf, pt, src_loc, nav, target), - .lea_uav => |uav| switch (try lf.lowerUav( + .lea_nav => |nav| switch (try genNavRef(lf, pt, src_loc, nav, target)) { + .sym_index => |sym_index| .{ .mcv = .{ .lea_symbol = sym_index } }, + .fail => |em| .{ .fail = em }, + }, + .load_uav, .lea_uav => |uav| switch (try lf.lowerUav( pt, uav.val, Type.fromInterned(uav.orig_ty).ptrAlignment(pt.zcu), src_loc, )) { - .mcv => |mcv| .{ .mcv = switch (mcv) { + .sym_index => |sym_index| .{ .mcv = switch (res) { else => unreachable, - .load_direct => |sym_index| .{ .lea_direct = sym_index }, - .load_symbol => |sym_index| .{ .lea_symbol = sym_index }, + .load_uav => .{ .load_symbol = sym_index }, + .lea_uav => .{ .lea_symbol = sym_index }, } }, .fail => |em| .{ .fail = em }, }, - .load_uav => |uav| lf.lowerUav( - pt, - uav.val, - Type.fromInterned(uav.orig_ty).ptrAlignment(pt.zcu), - src_loc, - ), }; } @@ -1076,8 +1075,8 @@ const LowerResult = union(enum) { /// such as ARM, the immediate will never exceed 32-bits. immediate: u64, lea_nav: InternPool.Nav.Index, - lea_uav: InternPool.Key.Ptr.BaseAddr.Uav, load_uav: InternPool.Key.Ptr.BaseAddr.Uav, + lea_uav: InternPool.Key.Ptr.BaseAddr.Uav, }; pub fn lowerValue(pt: Zcu.PerThread, val: Value, target: *const std.Target) Allocator.Error!LowerResult { diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 146148470f58..e1671e91401b 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -12115,7 +12115,7 @@ fn firstParamSRet(fn_info: InternPool.Key.FuncType, zcu: *Zcu, target: *const st return switch (fn_info.cc) { .auto => returnTypeByRef(zcu, target, return_type), .x86_64_sysv => firstParamSRetSystemV(return_type, zcu, target), - .x86_64_win => x86_64_abi.classifyWindows(return_type, zcu) == .memory, + .x86_64_win => x86_64_abi.classifyWindows(return_type, zcu, target) == .memory, .x86_sysv, .x86_win => isByRef(return_type, zcu), .x86_stdcall => !isScalar(zcu, return_type), .wasm_mvp => wasm_c_abi.classifyType(return_type, zcu) == .indirect, @@ -12215,7 +12215,7 @@ fn lowerFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Bu fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Error!Builder.Type { const zcu = o.pt.zcu; const return_type = Type.fromInterned(fn_info.return_type); - switch (x86_64_abi.classifyWindows(return_type, zcu)) { + switch (x86_64_abi.classifyWindows(return_type, zcu, zcu.getTarget())) { .integer => { if (isScalar(zcu, return_type)) { return o.lowerType(return_type); @@ -12239,7 +12239,6 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E return o.lowerType(return_type); } const classes = x86_64_abi.classifySystemV(return_type, zcu, zcu.getTarget(), .ret); - if (classes[0] == .memory) return .void; var types_index: u32 = 0; var types_buffer: [8]Builder.Type = undefined; for (classes) |class| { @@ -12274,15 +12273,9 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E types_index += 1; }, .x87up => continue, - .complex_x87 => { - @panic("TODO"); - }, - .memory => unreachable, // handled above - .win_i128 => unreachable, // windows only .none => break, - .integer_per_element => { - @panic("TODO"); - }, + .memory, .integer_per_element => return .void, + .win_i128 => unreachable, // windows only } } const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer}); @@ -12492,7 +12485,7 @@ const ParamTypeIterator = struct { fn nextWin64(it: *ParamTypeIterator, ty: Type) ?Lowering { const zcu = it.object.pt.zcu; - switch (x86_64_abi.classifyWindows(ty, zcu)) { + switch (x86_64_abi.classifyWindows(ty, zcu, zcu.getTarget())) { .integer => { if (isScalar(zcu, ty)) { it.zig_index += 1; @@ -12573,12 +12566,9 @@ const ParamTypeIterator = struct { return .byref; }, .x87up => unreachable, - .complex_x87 => { - @panic("TODO"); - }, + .none => break, .memory => unreachable, // handled above .win_i128 => unreachable, // windows only - .none => break, .integer_per_element => { @panic("TODO"); }, diff --git a/src/link.zig b/src/link.zig index 8833720828de..2a6e3b8031b3 100644 --- a/src/link.zig +++ b/src/link.zig @@ -920,7 +920,7 @@ pub const File = struct { decl_val: InternPool.Index, decl_align: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, - ) !codegen.GenResult { + ) !codegen.SymbolResult { assert(base.comp.zcu.?.llvm_object == null); switch (base.tag) { .lld => unreachable, diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 2ca7ec6de0fd..ea5d6a901c8e 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -752,7 +752,7 @@ fn shrinkAtom(coff: *Coff, atom_index: Atom.Index, new_block_size: u32) void { // capacity, insert a free list node for it. } -fn writeAtom(coff: *Coff, atom_index: Atom.Index, code: []u8) !void { +fn writeAtom(coff: *Coff, atom_index: Atom.Index, code: []u8, resolve_relocs: bool) !void { const atom = coff.getAtom(atom_index); const sym = atom.getSymbol(coff); const section = coff.sections.get(@intFromEnum(sym.section_number) - 1); @@ -774,11 +774,13 @@ fn writeAtom(coff: *Coff, atom_index: Atom.Index, code: []u8) !void { var relocs = std.ArrayList(*Relocation).init(gpa); defer relocs.deinit(); - if (coff.relocs.getPtr(atom_index)) |rels| { - try relocs.ensureTotalCapacityPrecise(rels.items.len); - for (rels.items) |*reloc| { - if (reloc.isResolvable(coff) and reloc.dirty) { - relocs.appendAssumeCapacity(reloc); + if (resolve_relocs) { + if (coff.relocs.getPtr(atom_index)) |rels| { + try relocs.ensureTotalCapacityPrecise(rels.items.len); + for (rels.items) |*reloc| { + if (reloc.isResolvable(coff) and reloc.dirty) { + relocs.appendAssumeCapacity(reloc); + } } } } @@ -812,12 +814,15 @@ fn writeAtom(coff: *Coff, atom_index: Atom.Index, code: []u8) !void { } } - coff.resolveRelocs(atom_index, relocs.items, code, coff.image_base); + if (resolve_relocs) { + coff.resolveRelocs(atom_index, relocs.items, code, coff.image_base); + } try coff.pwriteAll(code, file_offset); - - // Now we can mark the relocs as resolved. - while (relocs.pop()) |reloc| { - reloc.dirty = false; + if (resolve_relocs) { + // Now we can mark the relocs as resolved. + while (relocs.pop()) |reloc| { + reloc.dirty = false; + } } } @@ -914,6 +919,7 @@ fn writeOffsetTableEntry(coff: *Coff, index: usize) !void { } fn markRelocsDirtyByTarget(coff: *Coff, target: SymbolWithLoc) void { + if (!coff.base.comp.incremental) return; // TODO: reverse-lookup might come in handy here for (coff.relocs.values()) |*relocs| { for (relocs.items) |*reloc| { @@ -924,6 +930,7 @@ fn markRelocsDirtyByTarget(coff: *Coff, target: SymbolWithLoc) void { } fn markRelocsDirtyByAddress(coff: *Coff, addr: u32) void { + if (!coff.base.comp.incremental) return; const got_moved = blk: { const sect_id = coff.got_section_index orelse break :blk false; break :blk coff.sections.items(.header)[sect_id].virtual_address >= addr; @@ -1129,7 +1136,7 @@ fn lowerConst( log.debug("allocated atom for {s} at 0x{x}", .{ name, atom.getSymbol(coff).value }); log.debug(" (required alignment 0x{x})", .{required_alignment}); - try coff.writeAtom(atom_index, code); + try coff.writeAtom(atom_index, code, coff.base.comp.incremental); return .{ .ok = atom_index }; } @@ -1212,8 +1219,7 @@ fn updateLazySymbolAtom( }); defer gpa.free(name); - const atom = coff.getAtomPtr(atom_index); - const local_sym_index = atom.getSymbolIndex().?; + const local_sym_index = coff.getAtomPtr(atom_index).getSymbolIndex().?; const src = Type.fromInterned(sym.ty).srcLocOrNull(zcu) orelse Zcu.LazySrcLoc.unneeded; try codegen.generateLazySymbol( @@ -1228,12 +1234,13 @@ fn updateLazySymbolAtom( ); const code = code_buffer.items; - const code_len: u32 = @intCast(code.len); + const atom = coff.getAtomPtr(atom_index); const symbol = atom.getSymbolPtr(coff); try coff.setSymbolName(symbol, name); symbol.section_number = @enumFromInt(section_index + 1); symbol.type = .{ .complex_type = .NULL, .base_type = .NULL }; + const code_len: u32 = @intCast(code.len); const vaddr = try coff.allocateAtom(atom_index, code_len, @intCast(required_alignment.toByteUnits() orelse 0)); errdefer coff.freeAtom(atom_index); @@ -1244,7 +1251,7 @@ fn updateLazySymbolAtom( symbol.value = vaddr; try coff.addGotEntry(.{ .sym_index = local_sym_index }); - try coff.writeAtom(atom_index, code); + try coff.writeAtom(atom_index, code, coff.base.comp.incremental); } pub fn getOrCreateAtomForLazySymbol( @@ -1392,7 +1399,7 @@ fn updateNavCode( }; } - coff.writeAtom(atom_index, code) catch |err| switch (err) { + coff.writeAtom(atom_index, code, coff.base.comp.incremental) catch |err| switch (err) { error.OutOfMemory => return error.OutOfMemory, else => |e| return coff.base.cgFail(nav_index, "failed to write atom: {s}", .{@errorName(e)}), }; @@ -1430,7 +1437,7 @@ pub fn updateExports( const first_exp = export_indices[0].ptr(zcu); const res = try coff.lowerUav(pt, uav, .none, first_exp.src); switch (res) { - .mcv => {}, + .sym_index => {}, .fail => |em| { // TODO maybe it's enough to return an error here and let Module.processExportsInner // handle the error? @@ -1677,7 +1684,7 @@ fn flushInner(coff: *Coff, arena: Allocator, tid: Zcu.PerThread.Id) !void { const amt = try coff.base.file.?.preadAll(code.items, file_offset); if (amt != code.items.len) return error.InputOutput; - try coff.writeAtom(atom_index, code.items); + try coff.writeAtom(atom_index, code.items, true); } // Update GOT if it got moved in memory. @@ -1770,7 +1777,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { const zcu = pt.zcu; const gpa = zcu.gpa; const val = Value.fromInterned(uav); @@ -1782,7 +1789,7 @@ pub fn lowerUav( const atom = coff.getAtom(metadata.atom); const existing_addr = atom.getSymbol(coff).value; if (uav_alignment.check(existing_addr)) - return .{ .mcv = .{ .load_symbol = atom.getSymbolIndex().? } }; + return .{ .sym_index = atom.getSymbolIndex().? }; } var name_buf: [32]u8 = undefined; @@ -1813,9 +1820,7 @@ pub fn lowerUav( .atom = atom_index, .section = coff.rdata_section_index.?, }); - return .{ .mcv = .{ - .load_symbol = coff.getAtom(atom_index).getSymbolIndex().?, - } }; + return .{ .sym_index = coff.getAtom(atom_index).getSymbolIndex().? }; } pub fn getUavVAddr( @@ -2479,11 +2484,6 @@ const GetOrPutGlobalPtrResult = struct { value_ptr: *SymbolWithLoc, }; -/// Used only for disambiguating local from global at relocation level. -/// TODO this must go away. -pub const global_symbol_bit: u32 = 0x80000000; -pub const global_symbol_mask: u32 = 0x7fffffff; - /// Return pointer to the global entry for `name` if one exists. /// Puts a new global entry for `name` if one doesn't exist, and /// returns a pointer to it. diff --git a/src/link/Elf.zig b/src/link/Elf.zig index f4e903aa6a45..dc27e0bdd760 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -473,7 +473,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { return self.zigObjectPtr().?.lowerUav(self, pt, uav, explicit_alignment, src_loc); } diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig index d47488975c3e..f4b340a549d7 100644 --- a/src/link/Elf/ZigObject.zig +++ b/src/link/Elf/ZigObject.zig @@ -997,7 +997,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { const zcu = pt.zcu; const gpa = zcu.gpa; const val = Value.fromInterned(uav); @@ -1010,7 +1010,7 @@ pub fn lowerUav( const sym = self.symbol(metadata.symbol_index); const existing_alignment = sym.atom(elf_file).?.alignment; if (uav_alignment.order(existing_alignment).compare(.lte)) - return .{ .mcv = .{ .load_symbol = metadata.symbol_index } }; + return .{ .sym_index = metadata.symbol_index }; } const osec = if (self.data_relro_index) |sym_index| @@ -1047,12 +1047,11 @@ pub fn lowerUav( .{@errorName(e)}, ) }, }; - const sym_index = switch (res) { - .ok => |sym_index| sym_index, - .fail => |em| return .{ .fail = em }, - }; - try self.uavs.put(gpa, uav, .{ .symbol_index = sym_index, .allocated = true }); - return .{ .mcv = .{ .load_symbol = sym_index } }; + switch (res) { + .sym_index => |sym_index| try self.uavs.put(gpa, uav, .{ .symbol_index = sym_index, .allocated = true }), + .fail => {}, + } + return res; } pub fn getOrCreateMetadataForLazySymbol( @@ -1692,11 +1691,6 @@ fn updateLazySymbol( try elf_file.pwriteAll(code, atom_ptr.offset(elf_file)); } -const LowerConstResult = union(enum) { - ok: Symbol.Index, - fail: *Zcu.ErrorMsg, -}; - fn lowerConst( self: *ZigObject, elf_file: *Elf, @@ -1706,7 +1700,7 @@ fn lowerConst( required_alignment: InternPool.Alignment, output_section_index: u32, src_loc: Zcu.LazySrcLoc, -) !LowerConstResult { +) !codegen.SymbolResult { const gpa = pt.zcu.gpa; var code_buffer: std.ArrayListUnmanaged(u8) = .empty; @@ -1740,7 +1734,7 @@ fn lowerConst( try elf_file.pwriteAll(code, atom_ptr.offset(elf_file)); - return .{ .ok = sym_index }; + return .{ .sym_index = sym_index }; } pub fn updateExports( @@ -1764,7 +1758,7 @@ pub fn updateExports( const first_exp = export_indices[0].ptr(zcu); const res = try self.lowerUav(elf_file, pt, uav, .none, first_exp.src); switch (res) { - .mcv => {}, + .sym_index => {}, .fail => |em| { // TODO maybe it's enough to return an error here and let Zcu.processExportsInner // handle the error? diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 948b7022a280..744343526495 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -3092,7 +3092,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { return self.getZigObject().?.lowerUav(self, pt, uav, explicit_alignment, src_loc); } diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig index 1d7c2ceb1741..97c1a0ad54fe 100644 --- a/src/link/MachO/ZigObject.zig +++ b/src/link/MachO/ZigObject.zig @@ -704,7 +704,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: Atom.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { const zcu = pt.zcu; const gpa = zcu.gpa; const val = Value.fromInterned(uav); @@ -716,7 +716,7 @@ pub fn lowerUav( const sym = self.symbols.items[metadata.symbol_index]; const existing_alignment = sym.getAtom(macho_file).?.alignment; if (uav_alignment.order(existing_alignment).compare(.lte)) - return .{ .mcv = .{ .load_symbol = sym.nlist_idx } }; + return .{ .sym_index = metadata.symbol_index }; } var name_buf: [32]u8 = undefined; @@ -740,14 +740,11 @@ pub fn lowerUav( .{@errorName(e)}, ) }, }; - const sym_index = switch (res) { - .ok => |sym_index| sym_index, - .fail => |em| return .{ .fail = em }, - }; - try self.uavs.put(gpa, uav, .{ .symbol_index = sym_index }); - return .{ .mcv = .{ - .load_symbol = self.symbols.items[sym_index].nlist_idx, - } }; + switch (res) { + .sym_index => |sym_index| try self.uavs.put(gpa, uav, .{ .symbol_index = sym_index }), + .fail => {}, + } + return res; } fn freeNavMetadata(self: *ZigObject, macho_file: *MachO, sym_index: Symbol.Index) void { @@ -1187,11 +1184,6 @@ fn getNavOutputSection( return macho_file.zig_data_sect_index.?; } -const LowerConstResult = union(enum) { - ok: Symbol.Index, - fail: *Zcu.ErrorMsg, -}; - fn lowerConst( self: *ZigObject, macho_file: *MachO, @@ -1201,7 +1193,7 @@ fn lowerConst( required_alignment: Atom.Alignment, output_section_index: u8, src_loc: Zcu.LazySrcLoc, -) !LowerConstResult { +) !codegen.SymbolResult { const gpa = macho_file.base.comp.gpa; var code_buffer: std.ArrayListUnmanaged(u8) = .empty; @@ -1241,7 +1233,7 @@ fn lowerConst( const file_offset = sect.offset + atom.value; try macho_file.pwriteAll(code, file_offset); - return .{ .ok = sym_index }; + return .{ .sym_index = sym_index }; } pub fn updateExports( @@ -1265,7 +1257,7 @@ pub fn updateExports( const first_exp = export_indices[0].ptr(zcu); const res = try self.lowerUav(macho_file, pt, uav, .none, first_exp.src); switch (res) { - .mcv => {}, + .sym_index => {}, .fail => |em| { // TODO maybe it's enough to return an error here and let Zcu.processExportsInner // handle the error? diff --git a/src/link/Plan9.zig b/src/link/Plan9.zig index ce5e65f2c236..9658495bce16 100644 --- a/src/link/Plan9.zig +++ b/src/link/Plan9.zig @@ -1358,7 +1358,7 @@ pub fn lowerUav( uav: InternPool.Index, explicit_alignment: InternPool.Alignment, src_loc: Zcu.LazySrcLoc, -) !codegen.GenResult { +) !codegen.SymbolResult { _ = explicit_alignment; // example: // const ty = mod.intern_pool.typeOf(decl_val).toType(); @@ -1370,7 +1370,7 @@ pub fn lowerUav( // ... const gpa = self.base.comp.gpa; const gop = try self.uavs.getOrPut(gpa, uav); - if (gop.found_existing) return .{ .mcv = .{ .load_direct = gop.value_ptr.* } }; + if (gop.found_existing) return .{ .sym_index = gop.value_ptr.* }; const val = Value.fromInterned(uav); const name = try std.fmt.allocPrint(gpa, "__anon_{d}", .{@intFromEnum(uav)}); @@ -1395,7 +1395,7 @@ pub fn lowerUav( .value = undefined, .name = name, }; - return .{ .mcv = .{ .load_direct = index } }; + return .{ .sym_index = index }; } pub fn getUavVAddr(self: *Plan9, uav: InternPool.Index, reloc_info: link.File.RelocInfo) !u64 { diff --git a/test/behavior/abs.zig b/test/behavior/abs.zig index a3d8b1ffc771..530802a0cada 100644 --- a/test/behavior/abs.zig +++ b/test/behavior/abs.zig @@ -156,7 +156,6 @@ test "@abs floats" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try comptime testAbsFloats(f16); if (builtin.zig_backend != .stage2_riscv64) try testAbsFloats(f16); @@ -341,7 +340,6 @@ test "@abs float vectors" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; @setEvalBranchQuota(2000); try comptime testAbsFloatVectors(f16, 1); diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 5b7cd163bead..c8166a06ab67 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -302,19 +302,6 @@ test "array mult operator" { try expect(mem.eql(u8, "ab" ** 5, "ababababab")); } -const OpaqueA = opaque {}; -const OpaqueB = opaque {}; - -test "opaque types" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - - try expect(*OpaqueA != *OpaqueB); - - try expect(mem.eql(u8, @typeName(OpaqueA), "behavior.basic.OpaqueA")); - try expect(mem.eql(u8, @typeName(OpaqueB), "behavior.basic.OpaqueB")); -} - const global_a: i32 = 1234; const global_b: *const i32 = &global_a; const global_c: *const f32 = @as(*const f32, @ptrCast(global_b)); @@ -447,6 +434,7 @@ fn f2(x: bool) []const u8 { return (if (x) &fA else &fB)(); } +const OpaqueA = opaque {}; test "variable is allowed to be a pointer to an opaque type" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -1199,7 +1187,6 @@ test "arrays and vectors with big integers" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; diff --git a/test/behavior/bit_shifting.zig b/test/behavior/bit_shifting.zig index 4a1f65b38232..33742f21c40e 100644 --- a/test/behavior/bit_shifting.zig +++ b/test/behavior/bit_shifting.zig @@ -166,7 +166,6 @@ test "Saturating Shift Left" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn shlSat(x: anytype, y: std.math.Log2Int(@TypeOf(x))) @TypeOf(x) { diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig index 4242edaa6f21..052b66e532d1 100644 --- a/test/behavior/bitcast.zig +++ b/test/behavior/bitcast.zig @@ -302,7 +302,6 @@ test "@bitCast packed struct of floats" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const Foo = packed struct { @@ -342,7 +341,6 @@ test "comptime @bitCast packed struct to int and back" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = packed struct { void: void = {}, @@ -426,7 +424,6 @@ test "bitcast nan float does not modify signaling bit" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const snan_u16: u16 = 0x7D00; diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index d96f658ef8f0..d63991930ef9 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -126,7 +126,6 @@ test "@floatFromInt(f80)" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -1406,7 +1405,6 @@ test "cast f16 to wider types" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -1427,7 +1425,6 @@ test "cast f128 to narrower types" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -1521,7 +1518,7 @@ test "coerce between pointers of compatible differently-named floats" { if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows and !builtin.link_libc) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { @@ -1727,7 +1724,6 @@ test "peer type resolution: float and comptime-known fixed-width integer" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const i: u8 = 100; var f: f32 = 1.234; @@ -2477,7 +2473,6 @@ test "@floatCast on vector" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -2569,7 +2564,6 @@ test "@floatFromInt on vector" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const S = struct { @@ -2626,8 +2620,6 @@ test "@intFromBool on vector" { } test "numeric coercions with undefined" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; - const from: i32 = undefined; var to: f32 = from; to = @floatFromInt(from); @@ -2648,7 +2640,6 @@ test "@as does not corrupt values with incompatible representations" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const x: f32 = @as(f16, blk: { if (false) { diff --git a/test/behavior/eval.zig b/test/behavior/eval.zig index a5d737cb13c0..12e9de1825ef 100644 --- a/test/behavior/eval.zig +++ b/test/behavior/eval.zig @@ -526,7 +526,6 @@ test "runtime 128 bit integer division" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; var a: u128 = 152313999999999991610955792383; diff --git a/test/behavior/export_keyword.zig b/test/behavior/export_keyword.zig index 509925fe8c01..af2065067e87 100644 --- a/test/behavior/export_keyword.zig +++ b/test/behavior/export_keyword.zig @@ -40,7 +40,7 @@ export fn testPackedStuff(a: *const PackedStruct, b: *const PackedUnion) void { } test "export function alias" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; _ = struct { diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index 355032a24713..ba9231806777 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -16,9 +16,6 @@ fn epsForType(comptime T: type) T { test "add f16" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testAdd(f16); try comptime testAdd(f16); } @@ -31,7 +28,6 @@ test "add f32/f64" { } test "add f80/f128/c_longdouble" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -52,7 +48,6 @@ fn testAdd(comptime T: type) !void { } test "sub f16" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testSub(f16); @@ -67,7 +62,6 @@ test "sub f32/f64" { } test "sub f80/f128/c_longdouble" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -88,7 +82,6 @@ fn testSub(comptime T: type) !void { } test "mul f16" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testMul(f16); @@ -103,7 +96,6 @@ test "mul f32/f64" { } test "mul f80/f128/c_longdouble" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -128,9 +120,6 @@ test "cmp f16" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234 - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testCmp(f16); try comptime testCmp(f16); } @@ -158,7 +147,6 @@ test "cmp f128" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testCmp(f128); @@ -171,8 +159,8 @@ test "cmp f80/c_longdouble" { if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testCmp(f80); try comptime testCmp(f80); @@ -242,7 +230,6 @@ test "vector cmp f16" { if (builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testCmpVector(f16); try comptime testCmpVector(f16); @@ -256,7 +243,6 @@ test "vector cmp f32" { if (builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testCmpVector(f32); try comptime testCmpVector(f32); @@ -269,7 +255,6 @@ test "vector cmp f64" { if (builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testCmpVector(f64); try comptime testCmpVector(f64); @@ -285,7 +270,6 @@ test "vector cmp f128" { if (builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testCmpVector(f128); try comptime testCmpVector(f128); @@ -297,7 +281,7 @@ test "vector cmp f80/c_longdouble" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testCmpVector(f80); try comptime testCmpVector(f80); @@ -344,9 +328,6 @@ test "different sized float comparisons" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testDifferentSizedFloatComparisons(); try comptime testDifferentSizedFloatComparisons(); } @@ -395,9 +376,6 @@ test "@sqrt f16" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testSqrt(f16); try comptime testSqrt(f16); } @@ -418,9 +396,9 @@ test "@sqrt f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; if (builtin.os.tag == .freebsd) { // TODO https://github.com/ziglang/zig/issues/10875 @@ -527,7 +505,6 @@ test "@sin f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -539,7 +516,6 @@ test "@sin f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -553,9 +529,9 @@ test "@sin f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testSin(f80); comptime try testSin(f80); @@ -581,7 +557,6 @@ test "@sin with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -603,7 +578,6 @@ test "@cos f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -615,7 +589,6 @@ test "@cos f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -629,9 +602,9 @@ test "@cos f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testCos(f80); try comptime testCos(f80); @@ -657,7 +630,6 @@ test "@cos with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -679,7 +651,6 @@ test "@tan f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -691,7 +662,6 @@ test "@tan f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -705,9 +675,9 @@ test "@tan f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testTan(f80); try comptime testTan(f80); @@ -733,7 +703,6 @@ test "@tan with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -755,7 +724,6 @@ test "@exp f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -767,7 +735,6 @@ test "@exp f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -781,9 +748,9 @@ test "@exp f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testExp(f80); try comptime testExp(f80); @@ -813,7 +780,6 @@ test "@exp with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -835,7 +801,6 @@ test "@exp2 f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -847,7 +812,6 @@ test "@exp2 f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -861,9 +825,9 @@ test "@exp2 f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testExp2(f80); try comptime testExp2(f80); @@ -888,7 +852,6 @@ test "@exp2 with @vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -910,7 +873,6 @@ test "@log f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -922,7 +884,6 @@ test "@log f32/f64" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -936,9 +897,9 @@ test "@log f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testLog(f80); try comptime testLog(f80); @@ -964,7 +925,6 @@ test "@log with @vectors" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -983,7 +943,6 @@ test "@log2 f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -995,7 +954,6 @@ test "@log2 f32/f64" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -1009,9 +967,9 @@ test "@log2 f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testLog2(f80); try comptime testLog2(f80); @@ -1042,7 +1000,6 @@ test "@log2 with vectors" { if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testLog2WithVectors(); try comptime testLog2WithVectors(); @@ -1062,7 +1019,6 @@ test "@log10 f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -1074,7 +1030,6 @@ test "@log10 f32/f64" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -1088,9 +1043,9 @@ test "@log10 f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testLog10(f80); try comptime testLog10(f80); @@ -1115,7 +1070,6 @@ test "@log10 with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -1139,9 +1093,6 @@ test "@abs f16" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testFabs(f16); try comptime testFabs(f16); } @@ -1162,9 +1113,9 @@ test "@abs f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testFabs(f80); try comptime testFabs(f80); @@ -1262,7 +1213,6 @@ test "@floor f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testFloor(f16); @@ -1275,9 +1225,6 @@ test "@floor f32/f64" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testFloor(f32); try comptime testFloor(f32); try testFloor(f64); @@ -1342,9 +1289,6 @@ test "@floor with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testFloorWithVectors(); try comptime testFloorWithVectors(); } @@ -1363,7 +1307,6 @@ test "@ceil f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testCeil(f16); @@ -1376,9 +1319,6 @@ test "@ceil f32/f64" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testCeil(f32); try comptime testCeil(f32); try testCeil(f64); @@ -1443,9 +1383,6 @@ test "@ceil with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testCeilWithVectors(); try comptime testCeilWithVectors(); } @@ -1464,7 +1401,6 @@ test "@trunc f16" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testTrunc(f16); @@ -1477,9 +1413,6 @@ test "@trunc f32/f64" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testTrunc(f32); try comptime testTrunc(f32); try testTrunc(f64); @@ -1491,9 +1424,9 @@ test "@trunc f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) { // https://github.com/ziglang/zig/issues/12602 @@ -1544,9 +1477,6 @@ test "@trunc with vectors" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - try testTruncWithVectors(); try comptime testTruncWithVectors(); } @@ -1566,9 +1496,7 @@ test "neg f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.os.tag == .freebsd) { // TODO file issue to track this failure @@ -1597,8 +1525,8 @@ test "neg f80/f128/c_longdouble" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; try testNeg(f80); try comptime testNeg(f80); @@ -1704,7 +1632,6 @@ test "comptime fixed-width float zero divided by zero produces NaN" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; inline for (.{ f16, f32, f64, f80, f128 }) |F| { diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index 372f4407529d..bb7bf88676cd 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -587,7 +587,6 @@ fn StructCapture(comptime T: type) type { } test "call generic function that uses capture from function declaration's scope" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; diff --git a/test/behavior/math.zig b/test/behavior/math.zig index 83f18d890945..eb410f0efe26 100644 --- a/test/behavior/math.zig +++ b/test/behavior/math.zig @@ -65,7 +65,6 @@ test "@clz" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; try testClz(); @@ -474,9 +473,6 @@ test "division" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - try testIntDivision(); try comptime testIntDivision(); @@ -589,7 +585,6 @@ fn testFloatDivision() !void { } test "large integer division" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; @@ -615,7 +610,6 @@ test "division half-precision floats" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testDivisionFP16(); @@ -757,7 +751,6 @@ test "f128" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try test_f128(); @@ -843,7 +836,6 @@ test "128-bit multiplication" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @@ -1052,7 +1044,6 @@ test "@mulWithOverflow bitsize 128 bits" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555555, 0xffffffffffffffff_ffffffffffffffff, 0); try testMulWithOverflow(u128, 3, 0x5555555555555555_5555555555555556, 2, 1); @@ -1078,7 +1069,6 @@ test "@mulWithOverflow bitsize 256 bits" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; { const const_lhs: u256 = 8035709466408580321693645878924206181189; @@ -1475,7 +1465,6 @@ test "float remainder division using @rem" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime frem(f16); @@ -1560,7 +1549,6 @@ test "@round f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testRound(f16, 12.0); @@ -1571,7 +1559,6 @@ test "@round f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testRound(f64, 12.0); @@ -1591,7 +1578,6 @@ test "@round f80" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testRound(f80, 12.0); @@ -1604,7 +1590,6 @@ test "@round f128" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testRound(f128, 12.0); @@ -1624,7 +1609,6 @@ test "vector integer addition" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1646,7 +1630,6 @@ test "NaN comparison" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.cpu.arch.isArm() and builtin.target.abi.float() == .soft) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21234 @@ -1665,7 +1648,6 @@ test "NaN comparison f80" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try testNanEqNan(f80); @@ -1722,7 +1704,7 @@ test "signed zeros are represented properly" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1900,7 +1882,6 @@ test "partially-runtime integer vector division would be illegal if vector eleme if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; var lhs: @Vector(2, i8) = .{ -128, 5 }; const rhs: @Vector(2, i8) = .{ 1, -1 }; @@ -1930,9 +1911,6 @@ test "float vector division of comptime zero by runtime nan is nan" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .sse4_1)) return error.SkipZigTest; - const ct_zero: @Vector(1, f32) = .{0}; var rt_nan: @Vector(1, f32) = .{math.nan(f32)}; diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index d20bb4233741..b34df4b7842a 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -122,7 +122,6 @@ test "@min/max for floats" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest(comptime T: type) !void { diff --git a/test/behavior/memmove.zig b/test/behavior/memmove.zig index 8bfc8f66ad79..36af982c8474 100644 --- a/test/behavior/memmove.zig +++ b/test/behavior/memmove.zig @@ -9,7 +9,6 @@ test "memmove and memset intrinsics" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testMemmoveMemset(); try comptime testMemmoveMemset(); @@ -39,7 +38,6 @@ test "@memmove with both operands single-ptr-to-array, one is null-terminated" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testMemmoveBothSinglePtrArrayOneIsNullTerminated(); try comptime testMemmoveBothSinglePtrArrayOneIsNullTerminated(); @@ -85,7 +83,6 @@ test "@memmove dest many pointer" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testMemmoveDestManyPtr(); try comptime testMemmoveDestManyPtr(); @@ -129,7 +126,6 @@ test "@memmove slice" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testMemmoveSlice(); try comptime testMemmoveSlice(); diff --git a/test/behavior/muladd.zig b/test/behavior/muladd.zig index 87416d1af2d9..210485b23901 100644 --- a/test/behavior/muladd.zig +++ b/test/behavior/muladd.zig @@ -9,9 +9,6 @@ test "@mulAdd" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest; - try comptime testMulAdd(); try testMulAdd(); } @@ -37,7 +34,6 @@ test "@mulAdd f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -59,7 +55,6 @@ test "@mulAdd f80" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime testMulAdd80(); @@ -80,7 +75,6 @@ test "@mulAdd f128" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime testMulAdd128(); @@ -113,7 +107,6 @@ test "vector f16" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; @@ -142,9 +135,6 @@ test "vector f32" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest; - try comptime vector32(); try vector32(); } @@ -170,9 +160,6 @@ test "vector f64" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .fma)) return error.SkipZigTest; - try comptime vector64(); try vector64(); } @@ -196,7 +183,6 @@ test "vector f80" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime vector80(); @@ -223,7 +209,6 @@ test "vector f128" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; try comptime vector128(); diff --git a/test/behavior/multiple_externs_with_conflicting_types.zig b/test/behavior/multiple_externs_with_conflicting_types.zig index 37b6fd269c5b..7b3453695c70 100644 --- a/test/behavior/multiple_externs_with_conflicting_types.zig +++ b/test/behavior/multiple_externs_with_conflicting_types.zig @@ -15,7 +15,7 @@ test "call extern function defined with conflicting type" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; @import("conflicting_externs/a.zig").issue529(null); diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index 4e5f25f81d45..da67aee55ef8 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -59,7 +59,6 @@ fn testNullPtrsEql() !void { } test "optional with zero-bit type" { - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; const S = struct { diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig index 34659e08db27..e6b2409154ef 100644 --- a/test/behavior/packed-struct.zig +++ b/test/behavior/packed-struct.zig @@ -661,7 +661,6 @@ test "nested packed struct field access test" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; const Vec2 = packed struct { diff --git a/test/behavior/saturating_arithmetic.zig b/test/behavior/saturating_arithmetic.zig index 04cdbef05ecc..1abd5b4dabc0 100644 --- a/test/behavior/saturating_arithmetic.zig +++ b/test/behavior/saturating_arithmetic.zig @@ -58,7 +58,6 @@ test "saturating add 128bit" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -132,7 +131,6 @@ test "saturating subtraction 128bit" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -233,7 +231,6 @@ test "saturating multiplication <= 32 bits" { test "saturating mul i64, i128" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testSatMul(i64, 0, maxInt(i64), 0); try testSatMul(i64, 0, minInt(i64), 0); @@ -266,7 +263,6 @@ test "saturating multiplication" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isWasm()) { // https://github.com/ziglang/zig/issues/9660 @@ -304,7 +300,6 @@ test "saturating shift-left" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -349,7 +344,6 @@ test "saturating shift-left large rhs" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; { var lhs: u8 = undefined; @@ -368,7 +362,6 @@ test "saturating shl uses the LHS type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const lhs_const: u8 = 1; var lhs_var: u8 = 1; diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 6b6d4e7a34e1..365edcde698b 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -561,7 +561,6 @@ test "packed struct with non-ABI-aligned field" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = packed struct { x: u9, diff --git a/test/behavior/tuple.zig b/test/behavior/tuple.zig index 1f22ac20ae76..891dd2726e9a 100644 --- a/test/behavior/tuple.zig +++ b/test/behavior/tuple.zig @@ -397,7 +397,6 @@ test "tuple of struct concatenation and coercion to array" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; diff --git a/test/behavior/union.zig b/test/behavior/union.zig index b55aa9213486..106eb7de7702 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -282,7 +282,6 @@ test "cast union to tag type of union" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; try testCastUnionToTag(); try comptime testCastUnionToTag(); @@ -2262,7 +2261,6 @@ test "signed enum tag with negative value" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const Enum = enum(i8) { a = -1, diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 9ca822a37289..f2e580726770 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -80,7 +80,6 @@ test "vector int operators" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -104,7 +103,6 @@ test "vector float operators" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) { // Triggers an assertion with LLVM 18: @@ -260,9 +258,6 @@ test "array to vector with element type coercion" { if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt == .coff and - !comptime builtin.cpu.has(.x86, .f16c)) return error.SkipZigTest; - const S = struct { fn doTheTest() !void { var foo: f16 = 3.14; @@ -301,7 +296,6 @@ test "tuple to vector" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -365,7 +359,6 @@ test "vector @splat" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn testForT(comptime N: comptime_int, v: anytype) !void { @@ -567,7 +560,6 @@ test "vector division operators" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void { @@ -718,7 +710,6 @@ test "vector shift operators" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTestShift(x: anytype, y: anytype) !void { @@ -793,7 +784,6 @@ test "vector reduce operation" { if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isMIPS64()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/21091 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isSPARC()) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/23719 - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn testReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) !void { @@ -1047,7 +1037,6 @@ test "saturating shift-left" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1072,7 +1061,6 @@ test "multiplication-assignment operator with an array operand" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -1332,7 +1320,6 @@ test "zero multiplicand" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const zeros = @Vector(2, u32){ 0.0, 0.0 }; var ones = @Vector(2, u32){ 1.0, 1.0 }; @@ -1395,7 +1382,6 @@ test "load packed vector element" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; var x: @Vector(2, u15) = .{ 1, 4 }; @@ -1426,7 +1412,6 @@ test "store to vector in slice" { if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; var v = [_]@Vector(3, f32){ .{ 1, 1, 1 }, diff --git a/test/behavior/widening.zig b/test/behavior/widening.zig index be81ac4cf310..9219b3700f00 100644 --- a/test/behavior/widening.zig +++ b/test/behavior/widening.zig @@ -44,7 +44,6 @@ test "float widening" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; var a: f16 = 12.34; @@ -65,7 +64,6 @@ test "float widening f16 to f128" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; var x: f16 = 12.34; diff --git a/test/behavior/x86_64.zig b/test/behavior/x86_64.zig index def436dde45d..689b084858d6 100644 --- a/test/behavior/x86_64.zig +++ b/test/behavior/x86_64.zig @@ -5,8 +5,6 @@ test { if (builtin.zig_backend != .stage2_x86_64) return error.SkipZigTest; // MachO linker does not support executables this big. if (builtin.object_format == .macho) return error.SkipZigTest; - // COFF linker does not support the new backend. - if (builtin.object_format == .coff) return error.SkipZigTest; _ = @import("x86_64/access.zig"); _ = @import("x86_64/binary.zig"); _ = @import("x86_64/cast.zig"); diff --git a/test/behavior/x86_64/binary.zig b/test/behavior/x86_64/binary.zig index ee34840b9e1d..99dd47155bbf 100644 --- a/test/behavior/x86_64/binary.zig +++ b/test/behavior/x86_64/binary.zig @@ -14,6 +14,7 @@ const Log2Int = math.Log2Int; const math = @import("math.zig"); const nan = math.nan; const Scalar = math.Scalar; +const select = math.select; const sign = math.sign; const splat = math.splat; const Sse = math.Sse; @@ -84,6 +85,12 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela imm_rhs, ); } + fn testBools() !void { + try testArgs(bool, false, false); + try testArgs(bool, false, true); + try testArgs(bool, true, false); + try testArgs(bool, true, true); + } fn testInts() !void { try testArgs(i1, 0x0, -0x1); try testArgs(u1, 0x1, 0x1); @@ -1881,6 +1888,23 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela try testArgs(f128, nan(f128), inf(f128)); try testArgs(f128, nan(f128), nan(f128)); } + fn testBoolVectors() !void { + try testArgs(@Vector(1, bool), .{ + false, + }, .{ + true, + }); + try testArgs(@Vector(2, bool), .{ + false, true, + }, .{ + true, false, + }); + try testArgs(@Vector(4, bool), .{ + false, false, true, true, + }, .{ + false, true, false, true, + }); + } fn testIntVectors() !void { try testArgs(@Vector(1, i1), .{ 0x0, @@ -5033,8 +5057,7 @@ inline fn addSafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) { test addSafe { const test_add_safe = binary(addSafe, .{}); try test_add_safe.testInts(); - try test_add_safe.testFloats(); - try test_add_safe.testFloatVectors(); + try test_add_safe.testIntVectors(); } inline fn addWrap(comptime Type: type, lhs: Type, rhs: Type) Type { @@ -5046,13 +5069,13 @@ test addWrap { try test_add_wrap.testIntVectors(); } -inline fn addSat(comptime Type: type, lhs: Type, rhs: Type) Type { +inline fn addSaturate(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs +| rhs; } -test addSat { - const test_add_sat = binary(addSat, .{}); - try test_add_sat.testInts(); - try test_add_sat.testIntVectors(); +test addSaturate { + const test_add_saturate = binary(addSaturate, .{}); + try test_add_saturate.testInts(); + try test_add_saturate.testIntVectors(); } inline fn subUnsafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) { @@ -5088,8 +5111,7 @@ inline fn subSafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) { test subSafe { const test_sub_safe = binary(subSafe, .{}); try test_sub_safe.testInts(); - try test_sub_safe.testFloats(); - try test_sub_safe.testFloatVectors(); + try test_sub_safe.testIntVectors(); } inline fn subWrap(comptime Type: type, lhs: Type, rhs: Type) Type { @@ -5101,13 +5123,13 @@ test subWrap { try test_sub_wrap.testIntVectors(); } -inline fn subSat(comptime Type: type, lhs: Type, rhs: Type) Type { +inline fn subSaturate(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs -| rhs; } -test subSat { - const test_sub_sat = binary(subSat, .{}); - try test_sub_sat.testInts(); - try test_sub_sat.testIntVectors(); +test subSaturate { + const test_sub_saturate = binary(subSaturate, .{}); + try test_sub_saturate.testInts(); + try test_sub_saturate.testIntVectors(); } inline fn mulUnsafe(comptime Type: type, lhs: Type, rhs: Type) DoubleBits(Type) { @@ -5118,6 +5140,8 @@ test mulUnsafe { const test_mul_unsafe = binary(mulUnsafe, .{}); try test_mul_unsafe.testInts(); try test_mul_unsafe.testIntVectors(); + try test_mul_unsafe.testFloats(); + try test_mul_unsafe.testFloatVectors(); } inline fn mulSafe(comptime Type: type, lhs: Type, rhs: Type) DoubleBits(Type) { @@ -5127,6 +5151,7 @@ inline fn mulSafe(comptime Type: type, lhs: Type, rhs: Type) DoubleBits(Type) { test mulSafe { const test_mul_safe = binary(mulSafe, .{}); try test_mul_safe.testInts(); + try test_mul_safe.testIntVectors(); } inline fn mulWrap(comptime Type: type, lhs: Type, rhs: Type) Type { @@ -5138,16 +5163,16 @@ test mulWrap { try test_mul_wrap.testIntVectors(); } -inline fn mulSat(comptime Type: type, lhs: Type, rhs: Type) Type { +inline fn mulSaturate(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs *| rhs; } -test mulSat { - const test_mul_sat = binary(mulSat, .{}); - try test_mul_sat.testInts(); - try test_mul_sat.testIntVectors(); +test mulSaturate { + const test_mul_saturate = binary(mulSaturate, .{}); + try test_mul_saturate.testInts(); + try test_mul_saturate.testIntVectors(); } -inline fn multiply(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs * rhs) { +inline fn multiply(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs * rhs; } test multiply { @@ -5156,7 +5181,7 @@ test multiply { try test_multiply.testFloatVectors(); } -inline fn divide(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) { +inline fn divide(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs / rhs; } test divide { @@ -5165,29 +5190,49 @@ test divide { try test_divide.testFloatVectors(); } -inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@divTrunc(lhs, rhs)) { +inline fn divTruncUnoptimized(comptime Type: type, lhs: Type, rhs: Type) Type { return @divTrunc(lhs, rhs); } -test divTrunc { - const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int }); - try test_div_trunc.testInts(); - try test_div_trunc.testIntVectors(); - try test_div_trunc.testFloats(); - try test_div_trunc.testFloatVectors(); +test divTruncUnoptimized { + const test_div_trunc_unoptimized = binary(divTruncUnoptimized, .{ .compare = .approx_int }); + try test_div_trunc_unoptimized.testInts(); + try test_div_trunc_unoptimized.testIntVectors(); + try test_div_trunc_unoptimized.testFloats(); + try test_div_trunc_unoptimized.testFloatVectors(); +} + +inline fn divTruncOptimized(comptime Type: type, lhs: Type, rhs: Type) Type { + @setFloatMode(.optimized); + return @divTrunc(lhs, select(@abs(rhs) > splat(Type, 0.0), rhs, splat(Type, 1.0))); +} +test divTruncOptimized { + const test_div_trunc_optimized = binary(divTruncOptimized, .{ .compare = .approx_int }); + try test_div_trunc_optimized.testFloats(); + try test_div_trunc_optimized.testFloatVectors(); } -inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@divFloor(lhs, rhs)) { +inline fn divFloorUnoptimized(comptime Type: type, lhs: Type, rhs: Type) Type { return @divFloor(lhs, rhs); } -test divFloor { - const test_div_floor = binary(divFloor, .{ .compare = .approx_int }); - try test_div_floor.testInts(); - try test_div_floor.testIntVectors(); - try test_div_floor.testFloats(); - try test_div_floor.testFloatVectors(); +test divFloorUnoptimized { + const test_div_floor_unoptimized = binary(divFloorUnoptimized, .{ .compare = .approx_int }); + try test_div_floor_unoptimized.testInts(); + try test_div_floor_unoptimized.testIntVectors(); + try test_div_floor_unoptimized.testFloats(); + try test_div_floor_unoptimized.testFloatVectors(); +} + +inline fn divFloorOptimized(comptime Type: type, lhs: Type, rhs: Type) Type { + @setFloatMode(.optimized); + return @divFloor(lhs, select(@abs(rhs) > splat(Type, 0.0), rhs, splat(Type, 1.0))); +} +test divFloorOptimized { + const test_div_floor_optimized = binary(divFloorOptimized, .{ .compare = .approx_int }); + try test_div_floor_optimized.testFloats(); + try test_div_floor_optimized.testFloatVectors(); } -inline fn rem(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@rem(lhs, rhs)) { +inline fn rem(comptime Type: type, lhs: Type, rhs: Type) Type { return @rem(lhs, rhs); } test rem { @@ -5198,7 +5243,7 @@ test rem { try test_rem.testFloatVectors(); } -inline fn mod(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@mod(lhs, rhs)) { +inline fn mod(comptime Type: type, lhs: Type, rhs: Type) Type { // workaround llvm backend bugs if (@inComptime() and @typeInfo(Scalar(Type)) == .float) { const scalarMod = struct { @@ -5219,6 +5264,7 @@ inline fn mod(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@mod(lhs, rhs)) return @mod(lhs, rhs); } test mod { + if (@import("builtin").object_format == .coff) return error.SkipZigTest; const test_mod = binary(mod, .{}); try test_mod.testInts(); try test_mod.testIntVectors(); @@ -5286,7 +5332,7 @@ test shlWithOverflow { try test_shl_with_overflow.testIntVectors(); } -inline fn equal(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs == rhs) { +inline fn equal(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs == rhs; } test equal { @@ -5297,7 +5343,7 @@ test equal { try test_equal.testFloatVectors(); } -inline fn notEqual(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs != rhs) { +inline fn notEqual(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs != rhs; } test notEqual { @@ -5308,7 +5354,7 @@ test notEqual { try test_not_equal.testFloatVectors(); } -inline fn lessThan(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs < rhs) { +inline fn lessThan(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs < rhs; } test lessThan { @@ -5319,7 +5365,7 @@ test lessThan { try test_less_than.testFloatVectors(); } -inline fn lessThanOrEqual(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs <= rhs) { +inline fn lessThanOrEqual(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs <= rhs; } test lessThanOrEqual { @@ -5330,7 +5376,7 @@ test lessThanOrEqual { try test_less_than_or_equal.testFloatVectors(); } -inline fn greaterThan(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs > rhs) { +inline fn greaterThan(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs > rhs; } test greaterThan { @@ -5341,7 +5387,7 @@ test greaterThan { try test_greater_than.testFloatVectors(); } -inline fn greaterThanOrEqual(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs >= rhs) { +inline fn greaterThanOrEqual(comptime Type: type, lhs: Type, rhs: Type) ChangeScalar(Type, bool) { return lhs >= rhs; } test greaterThanOrEqual { @@ -5352,20 +5398,24 @@ test greaterThanOrEqual { try test_greater_than_or_equal.testFloatVectors(); } -inline fn bitAnd(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs & rhs) { +inline fn bitAnd(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs & rhs; } test bitAnd { const test_bit_and = binary(bitAnd, .{}); + try test_bit_and.testBools(); + try test_bit_and.testBoolVectors(); try test_bit_and.testInts(); try test_bit_and.testIntVectors(); } -inline fn bitOr(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs | rhs) { +inline fn bitOr(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs | rhs; } test bitOr { const test_bit_or = binary(bitOr, .{}); + try test_bit_or.testBools(); + try test_bit_or.testBoolVectors(); try test_bit_or.testInts(); try test_bit_or.testIntVectors(); } @@ -5417,7 +5467,7 @@ test shlExactUnsafe { try test_shl_exact_unsafe.testIntVectors(); } -inline fn shlSat(comptime Type: type, lhs: Type, rhs: Type) Type { +inline fn shlSaturate(comptime Type: type, lhs: Type, rhs: Type) Type { // workaround https://github.com/ziglang/zig/issues/23034 if (@inComptime()) { // workaround https://github.com/ziglang/zig/issues/23139 @@ -5427,17 +5477,19 @@ inline fn shlSat(comptime Type: type, lhs: Type, rhs: Type) Type { @setRuntimeSafety(false); return lhs <<| @abs(rhs); } -test shlSat { - const test_shl_sat = binary(shlSat, .{}); - try test_shl_sat.testInts(); - try test_shl_sat.testIntVectors(); +test shlSaturate { + const test_shl_saturate = binary(shlSaturate, .{}); + try test_shl_saturate.testInts(); + try test_shl_saturate.testIntVectors(); } -inline fn bitXor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs ^ rhs) { +inline fn bitXor(comptime Type: type, lhs: Type, rhs: Type) Type { return lhs ^ rhs; } test bitXor { const test_bit_xor = binary(bitXor, .{}); + try test_bit_xor.testBools(); + try test_bit_xor.testBoolVectors(); try test_bit_xor.testInts(); try test_bit_xor.testIntVectors(); } @@ -5516,7 +5568,7 @@ test reduceXorNotEqual { try test_reduce_xor_not_equal.testFloatVectors(); } -inline fn mulAdd(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@mulAdd(Type, lhs, rhs, rhs)) { +inline fn mulAdd(comptime Type: type, lhs: Type, rhs: Type) Type { return @mulAdd(Type, lhs, rhs, rhs); } test mulAdd { diff --git a/test/behavior/x86_64/build.zig b/test/behavior/x86_64/build.zig index 5aea349297d0..52aeba6d7d89 100644 --- a/test/behavior/x86_64/build.zig +++ b/test/behavior/x86_64/build.zig @@ -113,6 +113,51 @@ pub fn build(b: *std.Build) void { .cpu_arch = .x86_64, .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v4 }, }, + + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }, + .os_tag = .windows, + .abi = .none, + }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }, + .cpu_features_add = std.Target.x86.featureSet(&.{.ssse3}), + .os_tag = .windows, + .abi = .none, + }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v2 }, + .os_tag = .windows, + .abi = .none, + }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v3 }, + .os_tag = .windows, + .abi = .none, + }, + + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }, + .os_tag = .windows, + .abi = .gnu, + }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v2 }, + .os_tag = .windows, + .abi = .gnu, + }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v3 }, + .os_tag = .windows, + .abi = .gnu, + }, }) |query| { const target = b.resolveTargetQuery(query); const triple = query.zigTriple(b.allocator) catch @panic("OOM"); diff --git a/test/behavior/x86_64/cast.zig b/test/behavior/x86_64/cast.zig index 6e52dc33a2d4..dd538d9c67ee 100644 --- a/test/behavior/x86_64/cast.zig +++ b/test/behavior/x86_64/cast.zig @@ -14546,13 +14546,24 @@ test floatCast { try test_float_cast.testFloatVectors(); } -inline fn intFromFloat(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result { +inline fn intFromFloatUnsafe(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result { + @setRuntimeSafety(false); return @intFromFloat(rhs); } -test intFromFloat { - const test_int_from_float = cast(intFromFloat, .{ .compare = .strict }); - try test_int_from_float.testIntsFromFloats(); - try test_int_from_float.testIntVectorsFromFloatVectors(); +test intFromFloatUnsafe { + const test_int_from_float_unsafe = cast(intFromFloatUnsafe, .{ .compare = .strict }); + try test_int_from_float_unsafe.testIntsFromFloats(); + try test_int_from_float_unsafe.testIntVectorsFromFloatVectors(); +} + +inline fn intFromFloatSafe(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result { + @setRuntimeSafety(true); + return @intFromFloat(rhs); +} +test intFromFloatSafe { + const test_int_from_float_safe = cast(intFromFloatSafe, .{ .compare = .strict }); + try test_int_from_float_safe.testIntsFromFloats(); + try test_int_from_float_safe.testIntVectorsFromFloatVectors(); } inline fn floatFromInt(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result { diff --git a/test/behavior/x86_64/math.zig b/test/behavior/x86_64/math.zig index 759c8e8de90f..5f0473e0d575 100644 --- a/test/behavior/x86_64/math.zig +++ b/test/behavior/x86_64/math.zig @@ -35,10 +35,14 @@ pub fn ChangeScalar(comptime Type: type, comptime NewScalar: type) type { }; } pub fn AsSignedness(comptime Type: type, comptime signedness: std.builtin.Signedness) type { - return ChangeScalar(Type, @Type(.{ .int = .{ - .signedness = signedness, - .bits = @typeInfo(Scalar(Type)).int.bits, - } })); + return switch (@typeInfo(Scalar(Type))) { + .int => |int| ChangeScalar(Type, @Type(.{ .int = .{ + .signedness = signedness, + .bits = int.bits, + } })), + .float => Type, + else => @compileError(@typeName(Type)), + }; } pub fn AddOneBit(comptime Type: type) type { return ChangeScalar(Type, switch (@typeInfo(Scalar(Type))) { @@ -56,7 +60,10 @@ pub fn DoubleBits(comptime Type: type) type { } pub fn RoundBitsUp(comptime Type: type, comptime multiple: u16) type { return ChangeScalar(Type, switch (@typeInfo(Scalar(Type))) { - .int => |int| @Type(.{ .int = .{ .signedness = int.signedness, .bits = std.mem.alignForward(u16, int.bits, multiple) } }), + .int => |int| @Type(.{ .int = .{ + .signedness = int.signedness, + .bits = std.mem.alignForward(u16, int.bits, multiple), + } }), .float => Scalar(Type), else => @compileError(@typeName(Type)), }); @@ -67,61 +74,30 @@ pub fn Log2Int(comptime Type: type) type { pub fn Log2IntCeil(comptime Type: type) type { return ChangeScalar(Type, math.Log2IntCeil(Scalar(Type))); } -// inline to avoid a runtime `@splat` -pub inline fn splat(comptime Type: type, scalar: Scalar(Type)) Type { +pub fn splat(comptime Type: type, scalar: Scalar(Type)) Type { return switch (@typeInfo(Type)) { else => scalar, .vector => @splat(scalar), }; } -// inline to avoid a runtime `@select` -inline fn select(cond: anytype, lhs: anytype, rhs: @TypeOf(lhs)) @TypeOf(lhs) { +pub fn sign(rhs: anytype) ChangeScalar(@TypeOf(rhs), bool) { + const Int = ChangeScalar(@TypeOf(rhs), switch (@typeInfo(Scalar(@TypeOf(rhs)))) { + .int, .comptime_int => Scalar(@TypeOf(rhs)), + .float => |float| @Type(.{ .int = .{ + .signedness = .signed, + .bits = float.bits, + } }), + else => @compileError(@typeName(@TypeOf(rhs))), + }); + return @as(Int, @bitCast(rhs)) < splat(Int, 0); +} +pub fn select(cond: anytype, lhs: anytype, rhs: @TypeOf(lhs)) @TypeOf(lhs) { return switch (@typeInfo(@TypeOf(cond))) { .bool => if (cond) lhs else rhs, .vector => @select(Scalar(@TypeOf(lhs)), cond, lhs, rhs), else => @compileError(@typeName(@TypeOf(cond))), }; } -pub fn sign(rhs: anytype) ChangeScalar(@TypeOf(rhs), bool) { - const ScalarInt = @Type(.{ .int = .{ - .signedness = .unsigned, - .bits = @bitSizeOf(Scalar(@TypeOf(rhs))), - } }); - const VectorInt = ChangeScalar(@TypeOf(rhs), ScalarInt); - return @as(VectorInt, @bitCast(rhs)) & splat(VectorInt, @as(ScalarInt, 1) << @bitSizeOf(ScalarInt) - 1) != splat(VectorInt, 0); -} -fn boolAnd(lhs: anytype, rhs: @TypeOf(lhs)) @TypeOf(lhs) { - switch (@typeInfo(@TypeOf(lhs))) { - .bool => return lhs and rhs, - .vector => |vector| switch (vector.child) { - bool => { - const Bits = @Type(.{ .int = .{ .signedness = .unsigned, .bits = vector.len } }); - const lhs_bits: Bits = @bitCast(lhs); - const rhs_bits: Bits = @bitCast(rhs); - return @bitCast(lhs_bits & rhs_bits); - }, - else => {}, - }, - else => {}, - } - @compileError("unsupported boolAnd type: " ++ @typeName(@TypeOf(lhs))); -} -fn boolOr(lhs: anytype, rhs: @TypeOf(lhs)) @TypeOf(lhs) { - switch (@typeInfo(@TypeOf(lhs))) { - .bool => return lhs or rhs, - .vector => |vector| switch (vector.child) { - bool => { - const Bits = @Type(.{ .int = .{ .signedness = .unsigned, .bits = vector.len } }); - const lhs_bits: Bits = @bitCast(lhs); - const rhs_bits: Bits = @bitCast(rhs); - return @bitCast(lhs_bits | rhs_bits); - }, - else => {}, - }, - else => {}, - } - @compileError("unsupported boolOr type: " ++ @typeName(@TypeOf(lhs))); -} pub const Compare = enum { strict, relaxed, approx, approx_int, approx_or_overflow }; // noinline for a more helpful stack trace @@ -131,9 +107,9 @@ pub noinline fn checkExpected(expected: anytype, actual: @TypeOf(expected), comp else => expected != actual, .float => switch (compare) { .strict, .relaxed => { - const unequal = boolAnd(expected != actual, boolOr(expected == expected, actual == actual)); + const unequal = (expected != actual) & ((expected == expected) | (actual == actual)); break :unexpected switch (compare) { - .strict => boolOr(unequal, sign(expected) != sign(actual)), + .strict => unequal | (sign(expected) != sign(actual)), .relaxed => unequal, .approx, .approx_int, .approx_or_overflow => comptime unreachable, }; @@ -156,10 +132,10 @@ pub noinline fn checkExpected(expected: anytype, actual: @TypeOf(expected), comp break :unexpected switch (compare) { .strict, .relaxed => comptime unreachable, .approx, .approx_int => approx_unequal, - .approx_or_overflow => boolAnd(approx_unequal, boolOr(boolAnd( - @abs(expected) != splat(Expected, inf(Expected)), - @abs(actual) != splat(Expected, inf(Expected)), - ), sign(expected) != sign(actual))), + .approx_or_overflow => approx_unequal & + (((@abs(expected) != splat(Expected, inf(Expected))) & + (@abs(actual) != splat(Expected, inf(Expected)))) | + (sign(expected) != sign(actual))), }; }, }, diff --git a/test/behavior/x86_64/unary.zig b/test/behavior/x86_64/unary.zig index 132d17b42dcb..5fd6f137b285 100644 --- a/test/behavior/x86_64/unary.zig +++ b/test/behavior/x86_64/unary.zig @@ -1,9 +1,11 @@ +const AsSignedness = math.AsSignedness; const checkExpected = math.checkExpected; const Compare = math.Compare; const fmax = math.fmax; const fmin = math.fmin; const Gpr = math.Gpr; const inf = math.inf; +const Log2IntCeil = math.Log2IntCeil; const math = @import("math.zig"); const nan = math.nan; const RoundBitsUp = math.RoundBitsUp; @@ -56,6 +58,10 @@ fn unary(comptime op: anytype, comptime opts: struct { f128 => libc_name ++ "q", else => break :libc, }, + .library_name = switch (@import("builtin").object_format) { + else => null, + .coff => "compiler_rt", + }, }); switch (@typeInfo(Type)) { else => break :expected libc_func(imm_arg), @@ -98,6 +104,10 @@ fn unary(comptime op: anytype, comptime opts: struct { imm_arg, ); } + fn testBools() !void { + try testArgs(bool, false); + try testArgs(bool, true); + } fn testIntTypes() !void { try testArgs(i1, undefined); try testArgs(u1, undefined); @@ -4804,16 +4814,27 @@ fn unary(comptime op: anytype, comptime opts: struct { }; } -inline fn bitNot(comptime Type: type, rhs: Type) @TypeOf(~rhs) { +inline fn boolNot(comptime Type: type, rhs: Type) Type { + return !rhs; +} +test boolNot { + const test_bool_not = unary(boolNot, .{}); + try test_bool_not.testBools(); + try test_bool_not.testBoolVectors(); +} + +inline fn bitNot(comptime Type: type, rhs: Type) Type { return ~rhs; } test bitNot { const test_bit_not = unary(bitNot, .{}); + try test_bit_not.testBools(); + try test_bit_not.testBoolVectors(); try test_bit_not.testInts(); try test_bit_not.testIntVectors(); } -inline fn clz(comptime Type: type, rhs: Type) @TypeOf(@clz(rhs)) { +inline fn clz(comptime Type: type, rhs: Type) Log2IntCeil(Type) { return @clz(rhs); } test clz { @@ -4822,7 +4843,7 @@ test clz { try test_clz.testIntVectors(); } -inline fn ctz(comptime Type: type, rhs: Type) @TypeOf(@ctz(rhs)) { +inline fn ctz(comptime Type: type, rhs: Type) Log2IntCeil(Type) { return @ctz(rhs); } test ctz { @@ -4831,7 +4852,7 @@ test ctz { try test_ctz.testIntVectors(); } -inline fn popCount(comptime Type: type, rhs: Type) @TypeOf(@popCount(rhs)) { +inline fn popCount(comptime Type: type, rhs: Type) Log2IntCeil(Type) { return @popCount(rhs); } test popCount { @@ -4849,7 +4870,7 @@ test byteSwap { try test_byte_swap.testIntVectors(); } -inline fn bitReverse(comptime Type: type, rhs: Type) @TypeOf(@bitReverse(rhs)) { +inline fn bitReverse(comptime Type: type, rhs: Type) Type { return @bitReverse(rhs); } test bitReverse { @@ -4858,7 +4879,7 @@ test bitReverse { try test_bit_reverse.testIntVectors(); } -inline fn sqrt(comptime Type: type, rhs: Type) @TypeOf(@sqrt(rhs)) { +inline fn sqrt(comptime Type: type, rhs: Type) Type { return @sqrt(rhs); } test sqrt { @@ -4867,7 +4888,7 @@ test sqrt { try test_sqrt.testFloatVectors(); } -inline fn sin(comptime Type: type, rhs: Type) @TypeOf(@sin(rhs)) { +inline fn sin(comptime Type: type, rhs: Type) Type { return @sin(rhs); } test sin { @@ -4876,7 +4897,7 @@ test sin { try test_sin.testFloatVectors(); } -inline fn cos(comptime Type: type, rhs: Type) @TypeOf(@cos(rhs)) { +inline fn cos(comptime Type: type, rhs: Type) Type { return @cos(rhs); } test cos { @@ -4885,7 +4906,7 @@ test cos { try test_cos.testFloatVectors(); } -inline fn tan(comptime Type: type, rhs: Type) @TypeOf(@tan(rhs)) { +inline fn tan(comptime Type: type, rhs: Type) Type { return @tan(rhs); } test tan { @@ -4894,7 +4915,7 @@ test tan { try test_tan.testFloatVectors(); } -inline fn exp(comptime Type: type, rhs: Type) @TypeOf(@exp(rhs)) { +inline fn exp(comptime Type: type, rhs: Type) Type { return @exp(rhs); } test exp { @@ -4903,7 +4924,7 @@ test exp { try test_exp.testFloatVectors(); } -inline fn exp2(comptime Type: type, rhs: Type) @TypeOf(@exp2(rhs)) { +inline fn exp2(comptime Type: type, rhs: Type) Type { return @exp2(rhs); } test exp2 { @@ -4912,7 +4933,7 @@ test exp2 { try test_exp2.testFloatVectors(); } -inline fn log(comptime Type: type, rhs: Type) @TypeOf(@log(rhs)) { +inline fn log(comptime Type: type, rhs: Type) Type { return @log(rhs); } test log { @@ -4921,7 +4942,7 @@ test log { try test_log.testFloatVectors(); } -inline fn log2(comptime Type: type, rhs: Type) @TypeOf(@log2(rhs)) { +inline fn log2(comptime Type: type, rhs: Type) Type { return @log2(rhs); } test log2 { @@ -4930,7 +4951,7 @@ test log2 { try test_log2.testFloatVectors(); } -inline fn log10(comptime Type: type, rhs: Type) @TypeOf(@log10(rhs)) { +inline fn log10(comptime Type: type, rhs: Type) Type { return @log10(rhs); } test log10 { @@ -4939,7 +4960,7 @@ test log10 { try test_log10.testFloatVectors(); } -inline fn abs(comptime Type: type, rhs: Type) @TypeOf(@abs(rhs)) { +inline fn abs(comptime Type: type, rhs: Type) AsSignedness(Type, .unsigned) { return @abs(rhs); } test abs { @@ -4950,7 +4971,7 @@ test abs { try test_abs.testFloatVectors(); } -inline fn floor(comptime Type: type, rhs: Type) @TypeOf(@floor(rhs)) { +inline fn floor(comptime Type: type, rhs: Type) Type { return @floor(rhs); } test floor { @@ -4959,7 +4980,7 @@ test floor { try test_floor.testFloatVectors(); } -inline fn ceil(comptime Type: type, rhs: Type) @TypeOf(@ceil(rhs)) { +inline fn ceil(comptime Type: type, rhs: Type) Type { return @ceil(rhs); } test ceil { @@ -4968,7 +4989,7 @@ test ceil { try test_ceil.testFloatVectors(); } -inline fn round(comptime Type: type, rhs: Type) @TypeOf(@round(rhs)) { +inline fn round(comptime Type: type, rhs: Type) Type { return @round(rhs); } test round { @@ -4977,7 +4998,7 @@ test round { try test_round.testFloatVectors(); } -inline fn trunc(comptime Type: type, rhs: Type) @TypeOf(@trunc(rhs)) { +inline fn trunc(comptime Type: type, rhs: Type) Type { return @trunc(rhs); } test trunc { @@ -4986,7 +5007,7 @@ test trunc { try test_trunc.testFloatVectors(); } -inline fn negate(comptime Type: type, rhs: Type) @TypeOf(-rhs) { +inline fn negate(comptime Type: type, rhs: Type) Type { return -rhs; } test negate { @@ -5098,40 +5119,40 @@ test reduceXor { try test_reduce_xor.testIntVectors(); } -inline fn reduceMin(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { +inline fn reduceMinUnoptimized(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { return @reduce(.Min, rhs); } -test reduceMin { - const test_reduce_min = unary(reduceMin, .{}); - try test_reduce_min.testIntVectors(); - try test_reduce_min.testFloatVectors(); +test reduceMinUnoptimized { + const test_reduce_min_unoptimized = unary(reduceMinUnoptimized, .{}); + try test_reduce_min_unoptimized.testIntVectors(); + try test_reduce_min_unoptimized.testFloatVectors(); } -inline fn reduceMax(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { +inline fn reduceMaxUnoptimized(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { return @reduce(.Max, rhs); } -test reduceMax { - const test_reduce_max = unary(reduceMax, .{}); - try test_reduce_max.testIntVectors(); - try test_reduce_max.testFloatVectors(); +test reduceMaxUnoptimized { + const test_reduce_max_unoptimized = unary(reduceMaxUnoptimized, .{}); + try test_reduce_max_unoptimized.testIntVectors(); + try test_reduce_max_unoptimized.testFloatVectors(); } -inline fn reduceAdd(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { +inline fn reduceAddUnoptimized(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { return @reduce(.Add, rhs); } -test reduceAdd { - const test_reduce_add = unary(reduceAdd, .{}); - try test_reduce_add.testIntVectors(); - try test_reduce_add.testFloatVectors(); +test reduceAddUnoptimized { + const test_reduce_add_unoptimized = unary(reduceAddUnoptimized, .{}); + try test_reduce_add_unoptimized.testIntVectors(); + try test_reduce_add_unoptimized.testFloatVectors(); } -inline fn reduceMul(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { +inline fn reduceMulUnoptimized(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { return @reduce(.Mul, rhs); } -test reduceMul { - const test_reduce_mul = unary(reduceMul, .{}); - try test_reduce_mul.testIntVectors(); - try test_reduce_mul.testFloatVectors(); +test reduceMulUnoptimized { + const test_reduce_mul_unoptimized = unary(reduceMulUnoptimized, .{}); + try test_reduce_mul_unoptimized.testIntVectors(); + try test_reduce_mul_unoptimized.testFloatVectors(); } inline fn reduceMinOptimized(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child { diff --git a/test/tests.zig b/test/tests.zig index c7ed0e59b5b7..432557af0678 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -1558,6 +1558,15 @@ const test_targets = blk: { .use_llvm = false, .use_lld = false, }, + .{ + .target = .{ + .cpu_arch = .x86_64, + .os_tag = .windows, + .abi = .gnu, + }, + .use_llvm = false, + .use_lld = false, + }, .{ .target = .{ .cpu_arch = .x86_64,