motiejus/zig
1
Fork 0
Code Releases Activity

Merge pull request #23483 from alexrp/target-int-functions

Browse Source 
compiler: Move int size/alignment functions to `std.Target` and `std.zig.target`
This commit is contained in:
Alex Rønne Petersen
2025-04-11 17:40:47 +02:00
committed by GitHub
parent c82e1fe880 27cfff8f44
commit 90084f4ae3
31 changed files with 364 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/compiler/aro/aro/Compilation.zig vendored
View File

@@ -1087,7 +1087,7 @@ pub fn fixedEnumTagSpecifier(comp: *const Compilation) ?Type.Specifier {
}
pub fn getCharSignedness(comp: *const Compilation) std.builtin.Signedness {
return comp.langopts.char_signedness_override orelse comp.target.charSignedness();
return comp.langopts.char_signedness_override orelse comp.target.cCharSignedness();
}
/// Add built-in aro headers directory to system include paths

18
lib/compiler_rt/divmodei4.zig
View File

@@ -33,18 +33,20 @@ fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void {
if (r) |x| if (u_sign < 0) neg(x);
}
pub fn __divei4(r_q: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.c) void {
pub fn __divei4(q_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void {
@setRuntimeSafety(builtin.is_test);
const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const q = r_q[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
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]));
@call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
}
pub fn __modei4(r_p: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.c) void {
pub fn __modei4(r_p: [*]u8, u_p: [*]u8, v_p: [*]u8, bits: usize) callconv(.c) void {
@setRuntimeSafety(builtin.is_test);
const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const r = r_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
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]));
@call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
}

12
lib/compiler_rt/fixdfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixdfei, .{ .name = "__fixdfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixdfei(r: [*]u32, bits: usize, a: f64) callconv(.c) void {
return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixhfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixhfei, .{ .name = "__fixhfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixhfei(r: [*]u32, bits: usize, a: f16) callconv(.c) void {
return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixhfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixsfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixsfei, .{ .name = "__fixsfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixsfei(r: [*]u32, bits: usize, a: f32) callconv(.c) void {
return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixsfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixtfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixtfei, .{ .name = "__fixtfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixtfei(r: [*]u32, bits: usize, a: f128) callconv(.c) void {
return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixtfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixunsdfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixunsdfei(r: [*]u32, bits: usize, a: f64) callconv(.c) void {
return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixunshfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixunshfei(r: [*]u32, bits: usize, a: f16) callconv(.c) void {
return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixunssfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixunssfei(r: [*]u32, bits: usize, a: f32) callconv(.c) void {
return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixunstfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixunstfei(r: [*]u32, bits: usize, a: f128) callconv(.c) void {
return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixunsxfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixunsxfei(r: [*]u32, bits: usize, a: f80) callconv(.c) void {
return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.unsigned, @ptrCast(@alignCast(r[0..byte_size])), a);
}

12
lib/compiler_rt/fixxfei.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__fixxfei, .{ .name = "__fixxfei", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __fixxfei(r: [*]u32, bits: usize, a: f80) callconv(.c) void {
return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
pub fn __fixxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return bigIntFromFloat(.signed, @ptrCast(@alignCast(r[0..byte_size])), a);
}

6
lib/compiler_rt/float_from_int_test.zig
View File

@@ -1,8 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const math = std.math;
const endian = builtin.cpu.arch.endian();
const __floatunsihf = @import("floatunsihf.zig").__floatunsihf;
@@ -237,12 +235,10 @@ test "floatuntisf" {
fn test_floateisf(expected: u32, comptime T: type, a: T) !void {
const int = @typeInfo(T).int;
var a_buf: [@divExact(int.bits, 32)]u32 = undefined;
std.mem.writeInt(T, std.mem.asBytes(&a_buf), a, endian);
const r = switch (int.signedness) {
.signed => __floateisf,
.unsigned => __floatuneisf,
}(&a_buf, int.bits);
}(@ptrCast(&a), int.bits);
try testing.expect(expected == @as(u32, @bitCast(r)));
}

12
lib/compiler_rt/floateidf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floateidf(a: [*]const u32, bits: usize) callconv(.c) f64 {
return floatFromBigInt(f64, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f64, .signed, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floateihf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floateihf, .{ .name = "__floateihf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floateihf(a: [*]const u32, bits: usize) callconv(.c) f16 {
return floatFromBigInt(f16, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floateihf(a: [*]const u8, bits: usize) callconv(.c) f16 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f16, .signed, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floateisf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floateisf, .{ .name = "__floateisf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floateisf(a: [*]const u32, bits: usize) callconv(.c) f32 {
return floatFromBigInt(f32, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floateisf(a: [*]const u8, bits: usize) callconv(.c) f32 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f32, .signed, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floateitf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floateitf, .{ .name = "__floateitf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floateitf(a: [*]const u32, bits: usize) callconv(.c) f128 {
return floatFromBigInt(f128, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floateitf(a: [*]const u8, bits: usize) callconv(.c) f128 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f128, .signed, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floateixf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floateixf(a: [*]const u32, bits: usize) callconv(.c) f80 {
return floatFromBigInt(f80, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f80, .signed, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floatuneidf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floatuneidf, .{ .name = "__floatuneidf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floatuneidf(a: [*]const u32, bits: usize) callconv(.c) f64 {
return floatFromBigInt(f64, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floatuneidf(a: [*]const u8, bits: usize) callconv(.c) f64 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f64, .unsigned, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floatuneihf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floatuneihf, .{ .name = "__floatuneihf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floatuneihf(a: [*]const u32, bits: usize) callconv(.c) f16 {
return floatFromBigInt(f16, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floatuneihf(a: [*]const u8, bits: usize) callconv(.c) f16 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f16, .unsigned, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floatuneisf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floatuneisf, .{ .name = "__floatuneisf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floatuneisf(a: [*]const u32, bits: usize) callconv(.c) f32 {
return floatFromBigInt(f32, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floatuneisf(a: [*]const u8, bits: usize) callconv(.c) f32 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f32, .unsigned, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floatuneitf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floatuneitf(a: [*]const u32, bits: usize) callconv(.c) f128 {
return floatFromBigInt(f128, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f128, .unsigned, @ptrCast(@alignCast(a[0..byte_size])));
}

12
lib/compiler_rt/floatuneixf.zig
View File

@@ -1,6 +1,7 @@
const divCeil = @import("std").math.divCeil;
const common = @import("./common.zig");
const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
const std = @import("std");
const builtin = @import("builtin");
const common = @import("common.zig");
const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
pub const panic = common.panic;
@@ -8,6 +9,7 @@ comptime {
@export(&__floatuneixf, .{ .name = "__floatuneixf", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __floatuneixf(a: [*]const u32, bits: usize) callconv(.c) f80 {
return floatFromBigInt(f80, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
pub fn __floatuneixf(a: [*]const u8, bits: usize) callconv(.c) f80 {
const byte_size = std.zig.target.intByteSize(builtin.target, @intCast(bits));
return floatFromBigInt(f80, .unsigned, @ptrCast(@alignCast(a[0..byte_size])));
}

18
lib/compiler_rt/int_from_float_test.zig
View File

@@ -1,8 +1,6 @@
const std = @import("std");
const builtin = @import("builtin");
const testing = std.testing;
const math = std.math;
const endian = builtin.cpu.arch.endian();
const __fixunshfti = @import("fixunshfti.zig").__fixunshfti;
const __fixunsxfti = @import("fixunsxfti.zig").__fixunsxfti;
@@ -350,14 +348,12 @@ test "fixunssfti" {
fn test_fixsfei(comptime T: type, expected: T, a: f32) !void {
const int = @typeInfo(T).int;
var expected_buf: [@divExact(int.bits, 32)]u32 = undefined;
std.mem.writeInt(T, std.mem.asBytes(&expected_buf), expected, endian);
var actual_buf: [@divExact(int.bits, 32)]u32 = undefined;
var actual: T = undefined;
_ = switch (int.signedness) {
.signed => __fixsfei,
.unsigned => __fixunssfei,
}(&actual_buf, int.bits, a);
try testing.expect(std.mem.eql(u32, &expected_buf, &actual_buf));
}(@ptrCast(&actual), int.bits, a);
try testing.expect(expected == actual);
}
test "fixsfei" {
@@ -685,14 +681,12 @@ test "fixunsdfti" {
fn test_fixdfei(comptime T: type, expected: T, a: f64) !void {
const int = @typeInfo(T).int;
var expected_buf: [@divExact(int.bits, 32)]u32 = undefined;
std.mem.writeInt(T, std.mem.asBytes(&expected_buf), expected, endian);
var actual_buf: [@divExact(int.bits, 32)]u32 = undefined;
var actual: T = undefined;
_ = switch (int.signedness) {
.signed => __fixdfei,
.unsigned => __fixunsdfei,
}(&actual_buf, int.bits, a);
try testing.expect(std.mem.eql(u32, &expected_buf, &actual_buf));
}(@ptrCast(&actual), int.bits, a);
try testing.expect(expected == actual);
}
test "fixdfei" {

18
lib/compiler_rt/udivmodei4.zig
View File

@@ -112,19 +112,21 @@ pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
}
}
pub fn __udivei4(r_q: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize) callconv(.c) 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 u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const q = r_q[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
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]));
@call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
}
pub fn __umodei4(r_p: [*]u32, u_p: [*]const u32, v_p: [*]const u32, bits: usize) callconv(.c) void {
pub fn __umodei4(r_p: [*]u8, u_p: [*]const u8, v_p: [*]const u8, bits: usize) callconv(.c) void {
@setRuntimeSafety(builtin.is_test);
const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
const r = r_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
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]));
@call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
}

64
lib/std/Target.zig
View File

@@ -2695,7 +2695,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 charSignedness(target: Target) std.builtin.Signedness {
pub fn cCharSignedness(target: 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) {
@@ -3273,6 +3273,68 @@ pub fn cTypePreferredAlignment(target: Target, c_type: CType) u16 {
);
}
pub fn cMaxIntAlignment(target: std.Target) u16 {
return switch (target.cpu.arch) {
.avr => 1,
.msp430 => 2,
.xcore,
.propeller,
=> 4,
.amdgcn,
.arm,
.armeb,
.thumb,
.thumbeb,
.lanai,
.hexagon,
.mips,
.mipsel,
.powerpc,
.powerpcle,
.riscv32,
.s390x,
=> 8,
// Even LLVMABIAlignmentOfType(i128) agrees on these targets.
.aarch64,
.aarch64_be,
.bpfel,
.bpfeb,
.mips64,
.mips64el,
.nvptx,
.nvptx64,
.powerpc64,
.powerpc64le,
.riscv64,
.sparc,
.sparc64,
.wasm32,
.wasm64,
.x86,
.x86_64,
=> 16,
// Below this comment are unverified but based on the fact that C requires
// int128_t to be 16 bytes aligned, it's a safe default.
.arc,
.csky,
.kalimba,
.loongarch32,
.loongarch64,
.m68k,
.spirv,
.spirv32,
.spirv64,
.ve,
.xtensa,
=> 16,
};
}
pub fn cCallingConvention(target: Target) ?std.builtin.CallingConvention {
return switch (target.cpu.arch) {
.x86_64 => switch (target.os.tag) {

32
lib/std/zig/target.zig
View File

@@ -352,6 +352,38 @@ fn eqlIgnoreCase(ignore_case: bool, a: []const u8, b: []const u8) bool {
}
}
pub fn intByteSize(target: 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 {
return switch (target.cpu.arch) {
.x86 => switch (bits) {
0 => 0,
1...8 => 1,
9...16 => 2,
17...32 => 4,
33...64 => switch (target.os.tag) {
.uefi, .windows => 8,
else => 4,
},
else => 16,
},
.x86_64 => switch (bits) {
0 => 0,
1...8 => 1,
9...16 => 2,
17...32 => 4,
33...64 => 8,
else => 16,
},
else => return @min(
std.math.ceilPowerOfTwoPromote(u16, @as(u16, @intCast((@as(u17, bits) + 7) / 8))),
target.cMaxIntAlignment(),
),
};
}
const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;

114
src/Type.zig
View File

@@ -968,7 +968,7 @@ pub fn abiAlignmentInner(
else => switch (ip.indexToKey(ty.toIntern())) {
.int_type => |int_type| {
if (int_type.bits == 0) return .{ .scalar = .@"1" };
return .{ .scalar = intAbiAlignment(int_type.bits, target) };
return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, int_type.bits)) };
},
.ptr_type, .anyframe_type => {
return .{ .scalar = ptrAbiAlignment(target) };
@@ -1021,7 +1021,7 @@ pub fn abiAlignmentInner(
.error_set_type, .inferred_error_set_type => {
const bits = zcu.errorSetBits();
if (bits == 0) return .{ .scalar = .@"1" };
return .{ .scalar = intAbiAlignment(bits, target) };
return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, bits)) };
},
// represents machine code; not a pointer
@@ -1034,7 +1034,7 @@ pub fn abiAlignmentInner(
.usize,
.isize,
=> return .{ .scalar = intAbiAlignment(target.ptrBitWidth(), target) },
=> return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, target.ptrBitWidth())) },
.c_char => return .{ .scalar = cTypeAlign(target, .char) },
.c_short => return .{ .scalar = cTypeAlign(target, .short) },
@@ -1065,7 +1065,7 @@ pub fn abiAlignmentInner(
.anyerror, .adhoc_inferred_error_set => {
const bits = zcu.errorSetBits();
if (bits == 0) return .{ .scalar = .@"1" };
return .{ .scalar = intAbiAlignment(bits, target) };
return .{ .scalar = .fromByteUnits(std.zig.target.intAlignment(target, bits)) };
},
.void,
@@ -1297,7 +1297,7 @@ pub fn abiSizeInner(
else => switch (ip.indexToKey(ty.toIntern())) {
.int_type => |int_type| {
if (int_type.bits == 0) return .{ .scalar = 0 };
return .{ .scalar = intAbiSize(int_type.bits, target) };
return .{ .scalar = std.zig.target.intByteSize(target, int_type.bits) };
},
.ptr_type => |ptr_type| switch (ptr_type.flags.size) {
.slice => return .{ .scalar = @divExact(target.ptrBitWidth(), 8) * 2 },
@@ -1359,7 +1359,7 @@ pub fn abiSizeInner(
.error_set_type, .inferred_error_set_type => {
const bits = zcu.errorSetBits();
if (bits == 0) return .{ .scalar = 0 };
return .{ .scalar = intAbiSize(bits, target) };
return .{ .scalar = std.zig.target.intByteSize(target, bits) };
},
.error_union_type => |error_union_type| {
@@ -1452,7 +1452,7 @@ pub fn abiSizeInner(
.anyerror, .adhoc_inferred_error_set => {
const bits = zcu.errorSetBits();
if (bits == 0) return .{ .scalar = 0 };
return .{ .scalar = intAbiSize(bits, target) };
return .{ .scalar = std.zig.target.intByteSize(target, bits) };
},
.noreturn => unreachable,
@@ -1606,100 +1606,6 @@ pub fn ptrAbiAlignment(target: Target) Alignment {
return Alignment.fromNonzeroByteUnits(@divExact(target.ptrBitWidth(), 8));
}
pub fn intAbiSize(bits: u16, target: Target) u64 {
return intAbiAlignment(bits, target).forward(@as(u16, @intCast((@as(u17, bits) + 7) / 8)));
}
pub fn intAbiAlignment(bits: u16, target: Target) Alignment {
return switch (target.cpu.arch) {
.x86 => switch (bits) {
0 => .none,
1...8 => .@"1",
9...16 => .@"2",
17...32 => .@"4",
33...64 => switch (target.os.tag) {
.uefi, .windows => .@"8",
else => .@"4",
},
else => .@"16",
},
.x86_64 => switch (bits) {
0 => .none,
1...8 => .@"1",
9...16 => .@"2",
17...32 => .@"4",
33...64 => .@"8",
else => .@"16",
},
else => return Alignment.fromByteUnits(@min(
std.math.ceilPowerOfTwoPromote(u16, @as(u16, @intCast((@as(u17, bits) + 7) / 8))),
maxIntAlignment(target),
)),
};
}
pub fn maxIntAlignment(target: std.Target) u16 {
return switch (target.cpu.arch) {
.avr => 1,
.msp430 => 2,
.xcore,
.propeller,
=> 4,
.amdgcn,
.arm,
.armeb,
.thumb,
.thumbeb,
.lanai,
.hexagon,
.mips,
.mipsel,
.powerpc,
.powerpcle,
.riscv32,
.s390x,
=> 8,
// Even LLVMABIAlignmentOfType(i128) agrees on these targets.
.aarch64,
.aarch64_be,
.bpfel,
.bpfeb,
.mips64,
.mips64el,
.nvptx,
.nvptx64,
.powerpc64,
.powerpc64le,
.riscv64,
.sparc,
.sparc64,
.wasm32,
.wasm64,
.x86,
.x86_64,
=> 16,
// Below this comment are unverified but based on the fact that C requires
// int128_t to be 16 bytes aligned, it's a safe default.
.arc,
.csky,
.kalimba,
.loongarch32,
.loongarch64,
.m68k,
.spirv,
.spirv32,
.spirv64,
.ve,
.xtensa,
=> 16,
};
}
pub fn bitSize(ty: Type, zcu: *const Zcu) u64 {
return bitSizeInner(ty, .normal, zcu, {}) catch unreachable;
}
@@ -2331,7 +2237,7 @@ pub fn isInt(self: Type, zcu: *const Zcu) bool {
/// Returns true if and only if the type is a fixed-width, signed integer.
pub fn isSignedInt(ty: Type, zcu: *const Zcu) bool {
return switch (ty.toIntern()) {
.c_char_type => zcu.getTarget().charSignedness() == .signed,
.c_char_type => zcu.getTarget().cCharSignedness() == .signed,
.isize_type, .c_short_type, .c_int_type, .c_long_type, .c_longlong_type => true,
else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
.int_type => |int_type| int_type.signedness == .signed,
@@ -2343,7 +2249,7 @@ pub fn isSignedInt(ty: Type, zcu: *const Zcu) bool {
/// Returns true if and only if the type is a fixed-width, unsigned integer.
pub fn isUnsignedInt(ty: Type, zcu: *const Zcu) bool {
return switch (ty.toIntern()) {
.c_char_type => zcu.getTarget().charSignedness() == .unsigned,
.c_char_type => zcu.getTarget().cCharSignedness() == .unsigned,
.usize_type, .c_ushort_type, .c_uint_type, .c_ulong_type, .c_ulonglong_type => true,
else => switch (zcu.intern_pool.indexToKey(ty.toIntern())) {
.int_type => |int_type| int_type.signedness == .unsigned,
@@ -2374,7 +2280,7 @@ pub fn intInfo(starting_ty: Type, zcu: *const Zcu) InternPool.Key.IntType {
},
.usize_type => return .{ .signedness = .unsigned, .bits = target.ptrBitWidth() },
.isize_type => return .{ .signedness = .signed, .bits = target.ptrBitWidth() },
.c_char_type => return .{ .signedness = zcu.getTarget().charSignedness(), .bits = target.cTypeBitSize(.char) },
.c_char_type => return .{ .signedness = zcu.getTarget().cCharSignedness(), .bits = target.cTypeBitSize(.char) },
.c_short_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.short) },
.c_ushort_type => return .{ .signedness = .unsigned, .bits = target.cTypeBitSize(.ushort) },
.c_int_type => return .{ .signedness = .signed, .bits = target.cTypeBitSize(.int) },

168
src/arch/x86_64/CodeGen.zig
View File

@@ -15995,7 +15995,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
} },
}, .{
@@ -16028,7 +16028,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
} },
}, .{
@@ -16468,7 +16468,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .@"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), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
@@ -16504,7 +16504,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .@"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), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
@@ -72598,7 +72598,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -72633,7 +72633,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -72668,7 +72668,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -72703,7 +72703,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -72739,7 +72739,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -72775,7 +72775,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -74166,7 +74166,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -74200,7 +74200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -74234,7 +74234,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -74268,7 +74268,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -74626,7 +74626,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -74654,7 +74654,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -76322,7 +76322,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -76356,7 +76356,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -76390,7 +76390,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -76424,7 +76424,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -76459,7 +76459,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -76494,7 +76494,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77437,7 +77437,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
.{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77467,7 +77467,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
.{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77497,7 +77497,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
.{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77527,7 +77527,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
.{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77557,7 +77557,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
.{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77587,7 +77587,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
.{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
@@ -77620,7 +77620,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77655,7 +77655,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77690,7 +77690,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77725,7 +77725,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77760,7 +77760,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -77795,7 +77795,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ },
.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -78838,7 +78838,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -78866,7 +78866,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -78896,7 +78896,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -78930,7 +78930,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -78964,7 +78964,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -78998,7 +78998,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -79032,7 +79032,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -79066,7 +79066,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ },
@@ -79581,7 +79581,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -79609,7 +79609,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -81638,7 +81638,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -81672,7 +81672,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -81706,7 +81706,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
.{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
@@ -81741,7 +81741,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
.{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
@@ -81777,7 +81777,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -81811,7 +81811,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -81845,7 +81845,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ },
.{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ },
@@ -81880,7 +81880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ },
.{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ },
@@ -82358,7 +82358,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -82386,7 +82386,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -83892,7 +83892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -83926,7 +83926,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -83960,7 +83960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -83994,7 +83994,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -84688,7 +84688,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -84716,7 +84716,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -86579,7 +86579,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -86613,7 +86613,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -86647,7 +86647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -86681,7 +86681,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -86715,7 +86715,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -86749,7 +86749,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -87050,7 +87050,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -87078,7 +87078,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -87721,7 +87721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
.{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
@@ -87756,7 +87756,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
.{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
.{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ },
@@ -88057,7 +88057,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -88085,7 +88085,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
} },
}, .{
@@ -89261,7 +89261,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -89295,7 +89295,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -89329,7 +89329,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -89363,7 +89363,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -89397,7 +89397,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -89431,7 +89431,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
.{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .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), ._, ._ },
@@ -109873,7 +109873,7 @@ fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int {
.anyerror => .{ .signedness = .unsigned, .bits = zcu.errorSetBits() },
.isize => .{ .signedness = .signed, .bits = cg.target.ptrBitWidth() },
.usize => .{ .signedness = .unsigned, .bits = cg.target.ptrBitWidth() },
.c_char => .{ .signedness = cg.target.charSignedness(), .bits = cg.target.cTypeBitSize(.char) },
.c_char => .{ .signedness = cg.target.cCharSignedness(), .bits = cg.target.cTypeBitSize(.char) },
.c_short => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.short) },
.c_ushort => .{ .signedness = .unsigned, .bits = cg.target.cTypeBitSize(.short) },
.c_int => .{ .signedness = .signed, .bits = cg.target.cTypeBitSize(.int) },
@@ -114554,7 +114554,7 @@ const Temp = struct {
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
} },
}, .{
@@ -114587,7 +114587,7 @@ const Temp = struct {
.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
} },
}, .{
@@ -115027,7 +115027,7 @@ const Temp = struct {
.{ .@"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), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
@@ -115063,7 +115063,7 @@ const Temp = struct {
.{ .@"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), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_bit_size), ._, ._ },
.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
@@ -116414,7 +116414,6 @@ const Select = struct {
const none: Adjust = .{ .sign = .pos, .lhs = .none, .op = .mul, .rhs = .@"1" };
const sub_ptr_size: Adjust = .{ .sign = .neg, .lhs = .ptr_size, .op = .mul, .rhs = .@"1" };
const add_ptr_bit_size: Adjust = .{ .sign = .pos, .lhs = .ptr_bit_size, .op = .mul, .rhs = .@"1" };
const add_8_size: Adjust = .{ .sign = .pos, .lhs = .size, .op = .mul, .rhs = .@"8" };
const add_size: Adjust = .{ .sign = .pos, .lhs = .size, .op = .mul, .rhs = .@"1" };
const add_size_div_4: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"4" };
const add_size_div_8: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"8" };
@@ -116446,7 +116445,6 @@ const Select = struct {
const add_2_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"2" };
const add_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"1" };
const sub_len: Adjust = .{ .sign = .neg, .lhs = .len, .op = .mul, .rhs = .@"1" };
const add_8_elem_size: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .mul, .rhs = .@"8" };
const add_elem_size: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .mul, .rhs = .@"1" };
const add_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .div, .rhs = .@"8" };
const sub_elem_size_div_8: Adjust = .{ .sign = .neg, .lhs = .elem_size, .op = .div, .rhs = .@"8" };

15
src/codegen/c/Type.zig
View File

@@ -78,7 +78,7 @@ pub fn isInteger(ctype: CType) bool {
pub fn signedness(ctype: CType, mod: *Module) std.builtin.Signedness {
return switch (ctype.index) {
.char => mod.resolved_target.result.charSignedness(),
.char => mod.resolved_target.result.cCharSignedness(),
.@"signed char",
.short,
.int,
@@ -1319,10 +1319,9 @@ pub const Pool = struct {
},
else => {
const target = &mod.resolved_target.result;
const abi_align = Type.intAbiAlignment(int_info.bits, target.*);
const abi_align_bytes = abi_align.toByteUnits().?;
const abi_align_bytes = std.zig.target.intAlignment(target.*, int_info.bits);
const array_ctype = try pool.getArray(allocator, .{
.len = @divExact(Type.intAbiSize(int_info.bits, target.*), 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),
@@ -1333,7 +1332,7 @@ pub const Pool = struct {
.{
.name = .{ .index = .array },
.ctype = array_ctype,
.alignas = AlignAs.fromAbiAlignment(abi_align),
.alignas = AlignAs.fromAbiAlignment(.fromByteUnits(abi_align_bytes)),
},
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
@@ -1437,7 +1436,7 @@ pub const Pool = struct {
.name = .{ .index = .len },
.ctype = .usize,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(target.ptrBitWidth(), target.*),
.fromByteUnits(std.zig.target.intAlignment(target.*, target.ptrBitWidth())),
),
},
};
@@ -1937,7 +1936,7 @@ pub const Pool = struct {
.name = .{ .index = .len },
.ctype = .usize,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(target.ptrBitWidth(), target.*),
.fromByteUnits(std.zig.target.intAlignment(target.*, target.ptrBitWidth())),
),
},
};
@@ -2057,7 +2056,7 @@ pub const Pool = struct {
.name = .{ .index = .@"error" },
.ctype = error_set_ctype,
.alignas = AlignAs.fromAbiAlignment(
Type.intAbiAlignment(error_set_bits, target.*),
.fromByteUnits(std.zig.target.intAlignment(target.*, error_set_bits)),
),
},
.{

2
src/link/C.zig
View File

@@ -396,7 +396,7 @@ fn abiDefines(self: *C, target: std.Target) !std.ArrayList(u8) {
else => {},
}
try writer.print("#define ZIG_TARGET_MAX_INT_ALIGNMENT {d}\n", .{
Type.maxIntAlignment(target),
target.cMaxIntAlignment(),
});
return defines;
}