Commit eaa6218f09d12fc84a29462f8287c0e6ecfd6739 | zig

author	Jacob Young <jacobly@ziglang.org> 2024-02-04 05:48:25+01:00
committer	Jacob Young <jacobly@ziglang.org> 2024-02-04 22:58:38-05:00
log	eaa6218f09d12fc84a29462f8287c0e6ecfd6739
tree	b7d649de3f0f5185dbf2c5b75905edd33f271cf3
parent	f5dbcd1cb4374be619ba0b18e40a069a7e860d93

x86_64: fix errors compiling the compiler

This fixes issues targetting both `x86_64-linux` and `x86_64-macos` with
the self-hosted backend.

5 files changed, 55 insertions(+), 24 deletions(-)

lib
- std
  - crypto
    Certificate
    Bundle
    macos.zig
    tls
    Client.zig
src
- Sema.zig
- TypedValue.zig
- codegen
  - llvm
    Builder.zig

lib/std/crypto/Certificate/Bundle/macos.zig+2-2

...	@@ -21,7 +21,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {	...	@@ -21,7 +21,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {
21	const reader = stream.reader();	21	const reader = stream.reader();
22		22
23	const db_header = try reader.readStructEndian(ApplDbHeader, .big);	23	const db_header = try reader.readStructEndian(ApplDbHeader, .big);
24	assert(mem.eql(u8, "kych", &@as([4]u8, @bitCast(db_header.signature))));	24	assert(mem.eql(u8, &db_header.signature, "kych"));
25		25
26	try stream.seekTo(db_header.schema_offset);	26	try stream.seekTo(db_header.schema_offset);
27		27
...	@@ -73,7 +73,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {	...	@@ -73,7 +73,7 @@ pub fn rescanMac(cb: *Bundle, gpa: Allocator) RescanMacError!void {
73	}	73	}
74		74
75	const ApplDbHeader = extern struct {	75	const ApplDbHeader = extern struct {
76	signature: @Vector(4, u8),	76	signature: [4]u8,
77	version: u32,	77	version: u32,
78	header_size: u32,	78	header_size: u32,
79	schema_offset: u32,	79	schema_offset: u32,

lib/std/crypto/tls/Client.zig+39-12

 @@ -452,11 +452,20 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
                         if (ciphertext.len > cleartext_buf.len) return error.TlsRecordOverflow;
                         const cleartext = cleartext_buf[0..ciphertext.len];
                         const auth_tag = record_decoder.array(P.AEAD.tag_length).*;
-                        const V = @Vector(P.AEAD.nonce_length, u8);
+                        const nonce = if (builtin.zig_backend == .stage2_x86_64 and
-                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
-                        const operand: V = pad ++ @as([8]u8, @bitCast(big(read_seq)));
+                        nonce: {
+                            var nonce = p.server_handshake_iv;
+                            const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                            std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ read_seq, .big);
+                            break :nonce nonce;
+                        } else nonce: {
+                            const V = @Vector(P.AEAD.nonce_length, u8);
+                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            const operand: V = pad ++ @as([8]u8, @bitCast(big(read_seq)));
+                            break :nonce @as(V, p.server_handshake_iv) ^ operand;
+                        };
                         read_seq += 1;
-                        const nonce = @as(V, p.server_handshake_iv) ^ operand;
                         P.AEAD.decrypt(cleartext, ciphertext, auth_tag, record_header, nonce, p.server_handshake_key) catch
                             return error.TlsBadRecordMac;
                         break :c cleartext;
 @@ -806,7 +815,6 @@ fn prepareCiphertextRecord(
     switch (c.application_cipher) {
         inline else => |*p| {
             const P = @TypeOf(p.*);
-            const V = @Vector(P.AEAD.nonce_length, u8);
             const overhead_len = tls.record_header_len + P.AEAD.tag_length + 1;
             const close_notify_alert_reserved = tls.close_notify_alert.len + overhead_len;
             while (true) {
 @@ -838,10 +846,20 @@ fn prepareCiphertextRecord(
                 ciphertext_end += ciphertext_len;
                 const auth_tag = ciphertext_buf[ciphertext_end..][0..P.AEAD.tag_length];
                 ciphertext_end += auth_tag.len;
-                const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                const nonce = if (builtin.zig_backend == .stage2_x86_64 and
-                const operand: V = pad ++ @as([8]u8, @bitCast(big(c.write_seq)));
+                    P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
+                nonce: {
+                    var nonce = p.client_iv;
+                    const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                    std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.write_seq, .big);
+                    break :nonce nonce;
+                } else nonce: {
+                    const V = @Vector(P.AEAD.nonce_length, u8);
+                    const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                    const operand: V = pad ++ @as([8]u8, @bitCast(big(c.write_seq)));
+                    break :nonce @as(V, p.client_iv) ^ operand;
+                };
                 c.write_seq += 1; // TODO send key_update on overflow
-                const nonce = @as(V, p.client_iv) ^ operand;
                 P.AEAD.encrypt(ciphertext, auth_tag, cleartext, ad, nonce, p.client_key);
                 const record = ciphertext_buf[record_start..ciphertext_end];
 @@ -1102,15 +1120,24 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.os.iovec)
                 const cleartext = switch (c.application_cipher) {
                     inline else => |*p| c: {
                         const P = @TypeOf(p.*);
-                        const V = @Vector(P.AEAD.nonce_length, u8);
                         const ad = frag[in - 5 ..][0..5];
                         const ciphertext_len = record_len - P.AEAD.tag_length;
                         const ciphertext = frag[in..][0..ciphertext_len];
                         in += ciphertext_len;
                         const auth_tag = frag[in..][0..P.AEAD.tag_length].*;
-                        const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                        const nonce = if (builtin.zig_backend == .stage2_x86_64 and
-                        const operand: V = pad ++ @as([8]u8, @bitCast(big(c.read_seq)));
+                            P.AEAD.nonce_length > comptime std.simd.suggestVectorLength(u8) orelse 1)
-                        const nonce: [P.AEAD.nonce_length]u8 = @as(V, p.server_iv) ^ operand;
+                        nonce: {
+                            var nonce = p.server_iv;
+                            const operand = std.mem.readInt(u64, nonce[nonce.len - 8 ..], .big);
+                            std.mem.writeInt(u64, nonce[nonce.len - 8 ..], operand ^ c.read_seq, .big);
+                            break :nonce nonce;
+                        } else nonce: {
+                            const V = @Vector(P.AEAD.nonce_length, u8);
+                            const pad = [1]u8{0} ** (P.AEAD.nonce_length - 8);
+                            const operand: V = pad ++ @as([8]u8, @bitCast(big(c.read_seq)));
+                            break :nonce @as(V, p.server_iv) ^ operand;
+                        };
                         const out_buf = vp.peek();
                         const cleartext_buf = if (ciphertext.len <= out_buf.len)
                             out_buf

src/Sema.zig+2-1

src/TypedValue.zig+8-6

 @@ -310,11 +310,6 @@ pub fn print(
                 return writer.writeAll(" }");
             },
             .ptr => |ptr| {
-                if (ptr.addr == .int) {}
-                const ptr_ty = ip.indexToKey(ty.toIntern()).ptr_type;
-                if (ptr_ty.flags.size == .Slice) {}
                 switch (ptr.addr) {
                     .decl => |decl_index| {
                         const decl = mod.declPtr(decl_index);
 @@ -348,7 +343,14 @@ pub fn print(
                             .val = Value.fromInterned(field_val_ip),
                         }, writer, level - 1, mod);
                     },
-                    .int => unreachable,
+                    .int => |int_ip| {
+                        try writer.writeAll("@ptrFromInt(");
+                        try print(.{
+                            .ty = Type.usize,
+                            .val = Value.fromInterned(int_ip),
+                        }, writer, level - 1, mod);
+                        try writer.writeByte(')');
+                    },
                     .eu_payload => |eu_ip| {
                         try writer.writeAll("(payload of ");
                         try print(.{

src/codegen/llvm/Builder.zig+4-3

 @@ -9978,10 +9978,10 @@ fn fnTypeAssumeCapacity(
         }
         pub fn eql(ctx: @This(), lhs_key: Key, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
+            if (rhs_data.tag != tag) return false;
             var rhs_extra = ctx.builder.typeExtraDataTrail(Type.Function, rhs_data.data);
             const rhs_params = rhs_extra.trail.next(rhs_extra.data.params_len, Type, ctx.builder);
-            return rhs_data.tag == tag and lhs_key.ret == rhs_extra.data.ret and
+            return lhs_key.ret == rhs_extra.data.ret and std.mem.eql(Type, lhs_key.params, rhs_params);
-                std.mem.eql(Type, lhs_key.params, rhs_params);
         }
     };
     const gop = self.type_map.getOrPutAssumeCapacityAdapted(
 @@ -10161,9 +10161,10 @@ fn structTypeAssumeCapacity(
         }
         pub fn eql(ctx: @This(), lhs_key: []const Type, _: void, rhs_index: usize) bool {
             const rhs_data = ctx.builder.type_items.items[rhs_index];
+            if (rhs_data.tag != tag) return false;
             var rhs_extra = ctx.builder.typeExtraDataTrail(Type.Structure, rhs_data.data);
             const rhs_fields = rhs_extra.trail.next(rhs_extra.data.fields_len, Type, ctx.builder);
-            return rhs_data.tag == tag and std.mem.eql(Type, lhs_key, rhs_fields);
+            return std.mem.eql(Type, lhs_key, rhs_fields);
         }
     };
     const gop = self.type_map.getOrPutAssumeCapacityAdapted(fields, Adapter{ .builder = self });

...	@@ -20136,6 +20136,7 @@ fn finishStructInit(	...	@@ -20136,6 +20136,7 @@ fn finishStructInit(
20136	},	20136	},
20137	else => \|e\| return e,	20137	else => \|e\| return e,
20138	};	20138	};
		20139	try sema.resolveStructFieldInits(struct_ty);
20139	try sema.queueFullTypeResolution(struct_ty);	20140	try sema.queueFullTypeResolution(struct_ty);
20140	const struct_val = try block.addAggregateInit(struct_ty, field_inits);	20141	const struct_val = try block.addAggregateInit(struct_ty, field_inits);
20141	return sema.coerce(block, result_ty, struct_val, init_src);	20142	return sema.coerce(block, result_ty, struct_val, init_src);
...	@@ -35939,7 +35940,7 @@ pub fn resolveTypeFully(sema: *Sema, ty: Type) CompileError!void {	...	@@ -35939,7 +35940,7 @@ pub fn resolveTypeFully(sema: *Sema, ty: Type) CompileError!void {
35939	return sema.resolveTypeFully(ty.childType(mod));	35940	return sema.resolveTypeFully(ty.childType(mod));
35940	},	35941	},
35941	.Struct => switch (mod.intern_pool.indexToKey(ty.toIntern())) {	35942	.Struct => switch (mod.intern_pool.indexToKey(ty.toIntern())) {
35942	.struct_type => return sema.resolveStructFully(ty),	35943	.struct_type => try sema.resolveStructFully(ty),
35943	.anon_struct_type => \|tuple\| {	35944	.anon_struct_type => \|tuple\| {
35944	for (tuple.types.get(ip)) \|field_ty\| {	35945	for (tuple.types.get(ip)) \|field_ty\| {
35945	try sema.resolveTypeFully(Type.fromInterned(field_ty));	35946	try sema.resolveTypeFully(Type.fromInterned(field_ty));