motiejus/zig
1
Fork 0
Code Releases Activity

std.posix.iovec: use .base and .len instead of .iov_base and .iov_len

Browse Source
This commit is contained in:
Nameless
2024-04-26 12:57:03 -05:00
committed by Andrew Kelley
parent c231d94960
commit aecd9cc6d1
21 changed files with 270 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/compiler/objcopy.zig
View File

@@ -1285,7 +1285,7 @@ const ElfFileHelper = struct {
for (consolidated.items) |cmd| {
switch (cmd) {
.write_data => |data| {
var iovec = [_]std.posix.iovec_const{.{ .iov_base = data.data.ptr, .iov_len = data.data.len }};
var iovec = [_]std.posix.iovec_const{.{ .base = data.data.ptr, .len = data.data.len }};
try out_file.pwritevAll(&iovec, data.out_offset);
},
.copy_range => |range| {

60
lib/std/crypto/tls/Client.zig
View File

@@ -217,12 +217,12 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
{
var iovecs = [_]std.posix.iovec_const{
.{
.iov_base = &plaintext_header,
.iov_len = plaintext_header.len,
.base = &plaintext_header,
.len = plaintext_header.len,
},
.{
.iov_base = host.ptr,
.iov_len = host.len,
.base = host.ptr,
.len = host.len,
},
};
try stream.writevAll(&iovecs);
@@ -678,8 +678,8 @@ pub fn init(stream: anytype, ca_bundle: Certificate.Bundle, host: []const u8) In
const both_msgs = client_change_cipher_spec_msg ++ finished_msg;
var both_msgs_vec = [_]std.posix.iovec_const{.{
.iov_base = &both_msgs,
.iov_len = both_msgs.len,
.base = &both_msgs,
.len = both_msgs.len,
}};
try stream.writevAll(&both_msgs_vec);
@@ -776,8 +776,8 @@ pub fn writeEnd(c: *Client, stream: anytype, bytes: []const u8, end: bool) !usiz
var total_amt: usize = 0;
while (true) {
var amt = try stream.writev(iovecs_buf[i..iovec_end]);
while (amt >= iovecs_buf[i].iov_len) {
const encrypted_amt = iovecs_buf[i].iov_len;
while (amt >= iovecs_buf[i].len) {
const encrypted_amt = iovecs_buf[i].len;
total_amt += encrypted_amt - overhead_len;
amt -= encrypted_amt;
i += 1;
@@ -789,8 +789,8 @@ pub fn writeEnd(c: *Client, stream: anytype, bytes: []const u8, end: bool) !usiz
// not sent; otherwise the caller would not know to retry the call.
if (amt == 0 and (!end or i < iovec_end - 1)) return total_amt;
}
iovecs_buf[i].iov_base += amt;
iovecs_buf[i].iov_len -= amt;
iovecs_buf[i].base += amt;
iovecs_buf[i].len -= amt;
}
}
@@ -864,8 +864,8 @@ fn prepareCiphertextRecord(
const record = ciphertext_buf[record_start..ciphertext_end];
iovecs[iovec_end] = .{
.iov_base = record.ptr,
.iov_len = record.len,
.base = record.ptr,
.len = record.len,
};
iovec_end += 1;
}
@@ -885,7 +885,7 @@ pub fn eof(c: Client) bool {
/// If the number read is less than `len` it means the stream reached the end.
/// Reaching the end of the stream is not an error condition.
pub fn readAtLeast(c: *Client, stream: anytype, buffer: []u8, len: usize) !usize {
var iovecs = [1]std.posix.iovec{.{ .iov_base = buffer.ptr, .iov_len = buffer.len }};
var iovecs = [1]std.posix.iovec{.{ .base = buffer.ptr, .len = buffer.len }};
return readvAtLeast(c, stream, &iovecs, len);
}
@@ -928,12 +928,12 @@ pub fn readvAtLeast(c: *Client, stream: anytype, iovecs: []std.posix.iovec, len:
var amt = try c.readvAdvanced(stream, iovecs[vec_i..]);
off_i += amt;
if (c.eof() or off_i >= len) return off_i;
while (amt >= iovecs[vec_i].iov_len) {
amt -= iovecs[vec_i].iov_len;
while (amt >= iovecs[vec_i].len) {
amt -= iovecs[vec_i].len;
vec_i += 1;
}
iovecs[vec_i].iov_base += amt;
iovecs[vec_i].iov_len -= amt;
iovecs[vec_i].base += amt;
iovecs[vec_i].len -= amt;
}
}
@@ -1000,12 +1000,12 @@ pub fn readvAdvanced(c: *Client, stream: anytype, iovecs: []const std.posix.iove
var ask_iovecs_buf: [2]std.posix.iovec = .{
.{
.iov_base = first_iov.ptr,
.iov_len = first_iov.len,
.base = first_iov.ptr,
.len = first_iov.len,
},
.{
.iov_base = &in_stack_buffer,
.iov_len = in_stack_buffer.len,
.base = &in_stack_buffer,
.len = in_stack_buffer.len,
},
};
@@ -1364,12 +1364,12 @@ const VecPut = struct {
var bytes_i: usize = 0;
while (true) {
const v = vp.iovecs[vp.idx];
const dest = v.iov_base[vp.off..v.iov_len];
const dest = v.base[vp.off..v.len];
const src = bytes[bytes_i..][0..@min(dest.len, bytes.len - bytes_i)];
@memcpy(dest[0..src.len], src);
bytes_i += src.len;
vp.off += src.len;
if (vp.off >= v.iov_len) {
if (vp.off >= v.len) {
vp.off = 0;
vp.idx += 1;
if (vp.idx >= vp.iovecs.len) {
@@ -1388,7 +1388,7 @@ const VecPut = struct {
fn peek(vp: VecPut) []u8 {
if (vp.idx >= vp.iovecs.len) return &.{};
const v = vp.iovecs[vp.idx];
return v.iov_base[vp.off..v.iov_len];
return v.base[vp.off..v.len];
}
// After writing to the result of peek(), one can call next() to
@@ -1396,7 +1396,7 @@ const VecPut = struct {
fn next(vp: *VecPut, len: usize) void {
vp.total += len;
vp.off += len;
if (vp.off >= vp.iovecs[vp.idx].iov_len) {
if (vp.off >= vp.iovecs[vp.idx].len) {
vp.off = 0;
vp.idx += 1;
}
@@ -1405,9 +1405,9 @@ const VecPut = struct {
fn freeSize(vp: VecPut) usize {
if (vp.idx >= vp.iovecs.len) return 0;
var total: usize = 0;
total += vp.iovecs[vp.idx].iov_len - vp.off;
total += vp.iovecs[vp.idx].len - vp.off;
if (vp.idx + 1 >= vp.iovecs.len) return total;
for (vp.iovecs[vp.idx + 1 ..]) |v| total += v.iov_len;
for (vp.iovecs[vp.idx + 1 ..]) |v| total += v.len;
return total;
}
};
@@ -1416,11 +1416,11 @@ const VecPut = struct {
fn limitVecs(iovecs: []std.posix.iovec, len: usize) []std.posix.iovec {
var bytes_left: usize = len;
for (iovecs, 0..) |*iovec, vec_i| {
if (bytes_left <= iovec.iov_len) {
iovec.iov_len = bytes_left;
if (bytes_left <= iovec.len) {
iovec.len = bytes_left;
return iovecs[0 .. vec_i + 1];
}
bytes_left -= iovec.iov_len;
bytes_left -= iovec.len;
}
return iovecs;
}

64
lib/std/fs/File.zig
View File

@@ -1138,7 +1138,7 @@ pub fn readv(self: File, iovecs: []const posix.iovec) ReadError!usize {
// TODO improve this to use ReadFileScatter
if (iovecs.len == 0) return @as(usize, 0);
const first = iovecs[0];
return windows.ReadFile(self.handle, first.iov_base[0..first.iov_len], null);
return windows.ReadFile(self.handle, first.base[0..first.len], null);
}
return posix.readv(self.handle, iovecs);
@@ -1153,7 +1153,7 @@ pub fn readv(self: File, iovecs: []const posix.iovec) ReadError!usize {
/// reads from the underlying OS layer.
/// * The OS layer expects pointer addresses to be inside the application's address space
/// even if the length is zero. Meanwhile, in Zig, slices may have undefined pointer
/// addresses when the length is zero. So this function modifies the iov_base fields
/// addresses when the length is zero. So this function modifies the base fields
/// when the length is zero.
///
/// Related open issue: https://github.com/ziglang/zig/issues/7699
@@ -1165,7 +1165,7 @@ pub fn readvAll(self: File, iovecs: []posix.iovec) ReadError!usize {
// addresses outside the application's address space.
var garbage: [1]u8 = undefined;
for (iovecs) |*v| {
if (v.iov_len == 0) v.iov_base = &garbage;
if (v.len == 0) v.base = &garbage;
}
var i: usize = 0;
@@ -1174,15 +1174,15 @@ pub fn readvAll(self: File, iovecs: []posix.iovec) ReadError!usize {
var amt = try self.readv(iovecs[i..]);
var eof = amt == 0;
off += amt;
while (amt >= iovecs[i].iov_len) {
amt -= iovecs[i].iov_len;
while (amt >= iovecs[i].len) {
amt -= iovecs[i].len;
i += 1;
if (i >= iovecs.len) return off;
eof = false;
}
if (eof) return off;
iovecs[i].iov_base += amt;
iovecs[i].iov_len -= amt;
iovecs[i].base += amt;
iovecs[i].len -= amt;
}
}
@@ -1194,7 +1194,7 @@ pub fn preadv(self: File, iovecs: []const posix.iovec, offset: u64) PReadError!u
// TODO improve this to use ReadFileScatter
if (iovecs.len == 0) return @as(usize, 0);
const first = iovecs[0];
return windows.ReadFile(self.handle, first.iov_base[0..first.iov_len], offset);
return windows.ReadFile(self.handle, first.base[0..first.len], offset);
}
return posix.preadv(self.handle, iovecs, offset);
@@ -1217,15 +1217,15 @@ pub fn preadvAll(self: File, iovecs: []posix.iovec, offset: u64) PReadError!usiz
var amt = try self.preadv(iovecs[i..], offset + off);
var eof = amt == 0;
off += amt;
while (amt >= iovecs[i].iov_len) {
amt -= iovecs[i].iov_len;
while (amt >= iovecs[i].len) {
amt -= iovecs[i].len;
i += 1;
if (i >= iovecs.len) return off;
eof = false;
}
if (eof) return off;
iovecs[i].iov_base += amt;
iovecs[i].iov_len -= amt;
iovecs[i].base += amt;
iovecs[i].len -= amt;
}
}
@@ -1273,7 +1273,7 @@ pub fn writev(self: File, iovecs: []const posix.iovec_const) WriteError!usize {
// TODO improve this to use WriteFileScatter
if (iovecs.len == 0) return @as(usize, 0);
const first = iovecs[0];
return windows.WriteFile(self.handle, first.iov_base[0..first.iov_len], null);
return windows.WriteFile(self.handle, first.base[0..first.len], null);
}
return posix.writev(self.handle, iovecs);
@@ -1284,7 +1284,7 @@ pub fn writev(self: File, iovecs: []const posix.iovec_const) WriteError!usize {
/// writes from the underlying OS layer.
/// * The OS layer expects pointer addresses to be inside the application's address space
/// even if the length is zero. Meanwhile, in Zig, slices may have undefined pointer
/// addresses when the length is zero. So this function modifies the iov_base fields
/// addresses when the length is zero. So this function modifies the base fields
/// when the length is zero.
/// See https://github.com/ziglang/zig/issues/7699
/// See equivalent function: `std.net.Stream.writevAll`.
@@ -1296,19 +1296,19 @@ pub fn writevAll(self: File, iovecs: []posix.iovec_const) WriteError!void {
// addresses outside the application's address space.
var garbage: [1]u8 = undefined;
for (iovecs) |*v| {
if (v.iov_len == 0) v.iov_base = &garbage;
if (v.len == 0) v.base = &garbage;
}
var i: usize = 0;
while (true) {
var amt = try self.writev(iovecs[i..]);
while (amt >= iovecs[i].iov_len) {
amt -= iovecs[i].iov_len;
while (amt >= iovecs[i].len) {
amt -= iovecs[i].len;
i += 1;
if (i >= iovecs.len) return;
}
iovecs[i].iov_base += amt;
iovecs[i].iov_len -= amt;
iovecs[i].base += amt;
iovecs[i].len -= amt;
}
}
@@ -1320,7 +1320,7 @@ pub fn pwritev(self: File, iovecs: []posix.iovec_const, offset: u64) PWriteError
// TODO improve this to use WriteFileScatter
if (iovecs.len == 0) return @as(usize, 0);
const first = iovecs[0];
return windows.WriteFile(self.handle, first.iov_base[0..first.iov_len], offset);
return windows.WriteFile(self.handle, first.base[0..first.len], offset);
}
return posix.pwritev(self.handle, iovecs, offset);
@@ -1339,13 +1339,13 @@ pub fn pwritevAll(self: File, iovecs: []posix.iovec_const, offset: u64) PWriteEr
while (true) {
var amt = try self.pwritev(iovecs[i..], offset + off);
off += amt;
while (amt >= iovecs[i].iov_len) {
amt -= iovecs[i].iov_len;
while (amt >= iovecs[i].len) {
amt -= iovecs[i].len;
i += 1;
if (i >= iovecs.len) return;
}
iovecs[i].iov_base += amt;
iovecs[i].iov_len -= amt;
iovecs[i].base += amt;
iovecs[i].len -= amt;
}
}
@@ -1456,13 +1456,13 @@ fn writeFileAllSendfile(self: File, in_file: File, args: WriteFileOptions) posix
var i: usize = 0;
while (i < headers.len) {
amt = try posix.sendfile(out_fd, in_fd, offset, count, headers[i..], trls, flags);
while (amt >= headers[i].iov_len) {
amt -= headers[i].iov_len;
while (amt >= headers[i].len) {
amt -= headers[i].len;
i += 1;
if (i >= headers.len) break :hdrs;
}
headers[i].iov_base += amt;
headers[i].iov_len -= amt;
headers[i].base += amt;
headers[i].len -= amt;
}
}
if (count == 0) {
@@ -1482,13 +1482,13 @@ fn writeFileAllSendfile(self: File, in_file: File, args: WriteFileOptions) posix
}
var i: usize = 0;
while (i < trailers.len) {
while (amt >= trailers[i].iov_len) {
amt -= trailers[i].iov_len;
while (amt >= trailers[i].len) {
amt -= trailers[i].len;
i += 1;
if (i >= trailers.len) return;
}
trailers[i].iov_base += amt;
trailers[i].iov_len -= amt;
trailers[i].base += amt;
trailers[i].len -= amt;
amt = try posix.writev(self.handle, trailers[i..]);
}
}

56
lib/std/fs/test.zig
View File

@@ -1276,22 +1276,22 @@ test "writev, readv" {
var buf2: [line2.len]u8 = undefined;
var write_vecs = [_]posix.iovec_const{
.{
.iov_base = line1,
.iov_len = line1.len,
.base = line1,
.len = line1.len,
},
.{
.iov_base = line2,
.iov_len = line2.len,
.base = line2,
.len = line2.len,
},
};
var read_vecs = [_]posix.iovec{
.{
.iov_base = &buf2,
.iov_len = buf2.len,
.base = &buf2,
.len = buf2.len,
},
.{
.iov_base = &buf1,
.iov_len = buf1.len,
.base = &buf1,
.len = buf1.len,
},
};
@@ -1318,22 +1318,22 @@ test "pwritev, preadv" {
var buf2: [line2.len]u8 = undefined;
var write_vecs = [_]posix.iovec_const{
.{
.iov_base = line1,
.iov_len = line1.len,
.base = line1,
.len = line1.len,
},
.{
.iov_base = line2,
.iov_len = line2.len,
.base = line2,
.len = line2.len,
},
};
var read_vecs = [_]posix.iovec{
.{
.iov_base = &buf2,
.iov_len = buf2.len,
.base = &buf2,
.len = buf2.len,
},
.{
.iov_base = &buf1,
.iov_len = buf1.len,
.base = &buf1,
.len = buf1.len,
},
};
@@ -1378,12 +1378,12 @@ test "sendfile" {
const line2 = "second line\n";
var vecs = [_]posix.iovec_const{
.{
.iov_base = line1,
.iov_len = line1.len,
.base = line1,
.len = line1.len,
},
.{
.iov_base = line2,
.iov_len = line2.len,
.base = line2,
.len = line2.len,
},
};
@@ -1401,20 +1401,20 @@ test "sendfile" {
const trailer2 = "second trailer\n";
var hdtr = [_]posix.iovec_const{
.{
.iov_base = header1,
.iov_len = header1.len,
.base = header1,
.len = header1.len,
},
.{
.iov_base = header2,
.iov_len = header2.len,
.base = header2,
.len = header2.len,
},
.{
.iov_base = trailer1,
.iov_len = trailer1.len,
.base = trailer1,
.len = trailer1.len,
},
.{
.iov_base = trailer2,
.iov_len = trailer2.len,
.base = trailer2,
.len = trailer2.len,
},
};

6
lib/std/http/Client.zig
View File

@@ -253,7 +253,7 @@ pub const Connection = struct {
if (conn.read_end != conn.read_start) return;
var iovecs = [1]std.posix.iovec{
.{ .iov_base = &conn.read_buf, .iov_len = conn.read_buf.len },
.{ .base = &conn.read_buf, .len = conn.read_buf.len },
};
const nread = try conn.readvDirect(&iovecs);
if (nread == 0) return error.EndOfStream;
@@ -289,8 +289,8 @@ pub const Connection = struct {
}
var iovecs = [2]std.posix.iovec{
.{ .iov_base = buffer.ptr, .iov_len = buffer.len },
.{ .iov_base = &conn.read_buf, .iov_len = conn.read_buf.len },
.{ .base = buffer.ptr, .len = buffer.len },
.{ .base = &conn.read_buf, .len = conn.read_buf.len },
};
const nread = try conn.readvDirect(&iovecs);

112
lib/std/http/Server.zig
View File

@@ -442,42 +442,42 @@ pub const Request = struct {
var iovecs_len: usize = 0;
iovecs[iovecs_len] = .{
.iov_base = h.items.ptr,
.iov_len = h.items.len,
.base = h.items.ptr,
.len = h.items.len,
};
iovecs_len += 1;
for (options.extra_headers) |header| {
iovecs[iovecs_len] = .{
.iov_base = header.name.ptr,
.iov_len = header.name.len,
.base = header.name.ptr,
.len = header.name.len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = ": ",
.iov_len = 2,
.base = ": ",
.len = 2,
};
iovecs_len += 1;
if (header.value.len != 0) {
iovecs[iovecs_len] = .{
.iov_base = header.value.ptr,
.iov_len = header.value.len,
.base = header.value.ptr,
.len = header.value.len,
};
iovecs_len += 1;
}
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
}
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
@@ -492,33 +492,33 @@ pub const Request = struct {
) catch unreachable;
iovecs[iovecs_len] = .{
.iov_base = chunk_header.ptr,
.iov_len = chunk_header.len,
.base = chunk_header.ptr,
.len = chunk_header.len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = content.ptr,
.iov_len = content.len,
.base = content.ptr,
.len = content.len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
}
iovecs[iovecs_len] = .{
.iov_base = "0\r\n\r\n",
.iov_len = 5,
.base = "0\r\n\r\n",
.len = 5,
};
iovecs_len += 1;
} else if (content.len > 0) {
iovecs[iovecs_len] = .{
.iov_base = content.ptr,
.iov_len = content.len,
.base = content.ptr,
.len = content.len,
};
iovecs_len += 1;
}
@@ -912,12 +912,12 @@ pub const Response = struct {
const send_buffer_len = r.send_buffer_end - r.send_buffer_start;
var iovecs: [2]std.posix.iovec_const = .{
.{
.iov_base = r.send_buffer.ptr + r.send_buffer_start,
.iov_len = send_buffer_len,
.base = r.send_buffer.ptr + r.send_buffer_start,
.len = send_buffer_len,
},
.{
.iov_base = bytes.ptr,
.iov_len = bytes.len,
.base = bytes.ptr,
.len = bytes.len,
},
};
const n = try r.stream.writev(&iovecs);
@@ -959,24 +959,24 @@ pub const Response = struct {
var iovecs: [5]std.posix.iovec_const = .{
.{
.iov_base = r.send_buffer.ptr + r.send_buffer_start,
.iov_len = send_buffer_len - r.chunk_len,
.base = r.send_buffer.ptr + r.send_buffer_start,
.len = send_buffer_len - r.chunk_len,
},
.{
.iov_base = chunk_header.ptr,
.iov_len = chunk_header.len,
.base = chunk_header.ptr,
.len = chunk_header.len,
},
.{
.iov_base = r.send_buffer.ptr + r.send_buffer_end - r.chunk_len,
.iov_len = r.chunk_len,
.base = r.send_buffer.ptr + r.send_buffer_end - r.chunk_len,
.len = r.chunk_len,
},
.{
.iov_base = bytes.ptr,
.iov_len = bytes.len,
.base = bytes.ptr,
.len = bytes.len,
},
.{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
},
};
// TODO make this writev instead of writevAll, which involves
@@ -1042,69 +1042,69 @@ pub const Response = struct {
var iovecs_len: usize = 0;
iovecs[iovecs_len] = .{
.iov_base = http_headers.ptr,
.iov_len = http_headers.len,
.base = http_headers.ptr,
.len = http_headers.len,
};
iovecs_len += 1;
if (r.chunk_len > 0) {
iovecs[iovecs_len] = .{
.iov_base = chunk_header.ptr,
.iov_len = chunk_header.len,
.base = chunk_header.ptr,
.len = chunk_header.len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = r.send_buffer.ptr + r.send_buffer_end - r.chunk_len,
.iov_len = r.chunk_len,
.base = r.send_buffer.ptr + r.send_buffer_end - r.chunk_len,
.len = r.chunk_len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
}
if (end_trailers) |trailers| {
iovecs[iovecs_len] = .{
.iov_base = "0\r\n",
.iov_len = 3,
.base = "0\r\n",
.len = 3,
};
iovecs_len += 1;
for (trailers) |trailer| {
iovecs[iovecs_len] = .{
.iov_base = trailer.name.ptr,
.iov_len = trailer.name.len,
.base = trailer.name.ptr,
.len = trailer.name.len,
};
iovecs_len += 1;
iovecs[iovecs_len] = .{
.iov_base = ": ",
.iov_len = 2,
.base = ": ",
.len = 2,
};
iovecs_len += 1;
if (trailer.value.len != 0) {
iovecs[iovecs_len] = .{
.iov_base = trailer.value.ptr,
.iov_len = trailer.value.len,
.base = trailer.value.ptr,
.len = trailer.value.len,
};
iovecs_len += 1;
}
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
}
iovecs[iovecs_len] = .{
.iov_base = "\r\n",
.iov_len = 2,
.base = "\r\n",
.len = 2,
};
iovecs_len += 1;
}

10
lib/std/net.zig
View File

@@ -1826,7 +1826,7 @@ pub const Stream = struct {
// TODO improve this to use ReadFileScatter
if (iovecs.len == 0) return @as(usize, 0);
const first = iovecs[0];
return windows.ReadFile(s.handle, first.iov_base[0..first.iov_len], null);
return windows.ReadFile(s.handle, first.base[0..first.len], null);
}
return posix.readv(s.handle, iovecs);
@@ -1889,13 +1889,13 @@ pub const Stream = struct {
var i: usize = 0;
while (true) {
var amt = try self.writev(iovecs[i..]);
while (amt >= iovecs[i].iov_len) {
amt -= iovecs[i].iov_len;
while (amt >= iovecs[i].len) {
amt -= iovecs[i].len;
i += 1;
if (i >= iovecs.len) return;
}
iovecs[i].iov_base += amt;
iovecs[i].iov_len -= amt;
iovecs[i].base += amt;
iovecs[i].len -= amt;
}
}
};

4
lib/std/os/linux.zig
View File

@@ -1644,7 +1644,7 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize
var size: i32 = 0;
const msg_iovlen = @as(usize, @intCast(msg.msg_hdr.msg_iovlen)); // kernel side this is treated as unsigned
for (msg.msg_hdr.msg_iov[0..msg_iovlen]) |iov| {
if (iov.iov_len > std.math.maxInt(i32) or @addWithOverflow(size, @as(i32, @intCast(iov.iov_len)))[1] != 0) {
if (iov.len > std.math.maxInt(i32) or @addWithOverflow(size, @as(i32, @intCast(iov.len)))[1] != 0) {
// batch-send all messages up to the current message
if (next_unsent < i) {
const batch_size = i - next_unsent;
@@ -1660,7 +1660,7 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize
next_unsent = i + 1;
break;
}
size += iov.iov_len;
size += iov.len;
}
}
if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG.EOR)

24
lib/std/os/linux/IoUring.zig
View File

@@ -1766,7 +1766,7 @@ test "readv" {
try ring.register_files(registered_fds[0..]);
var buffer = [_]u8{42} ** 128;
var iovecs = [_]posix.iovec{posix.iovec{ .iov_base = &buffer, .iov_len = buffer.len }};
var iovecs = [_]posix.iovec{posix.iovec{ .base = &buffer, .len = buffer.len }};
const sqe = try ring.read(0xcccccccc, fd_index, .{ .iovecs = iovecs[0..] }, 0);
try testing.expectEqual(linux.IORING_OP.READV, sqe.opcode);
sqe.flags |= linux.IOSQE_FIXED_FILE;
@@ -1803,11 +1803,11 @@ test "writev/fsync/readv" {
const buffer_write = [_]u8{42} ** 128;
const iovecs_write = [_]posix.iovec_const{
posix.iovec_const{ .iov_base = &buffer_write, .iov_len = buffer_write.len },
posix.iovec_const{ .base = &buffer_write, .len = buffer_write.len },
};
var buffer_read = [_]u8{0} ** 128;
var iovecs_read = [_]posix.iovec{
posix.iovec{ .iov_base = &buffer_read, .iov_len = buffer_read.len },
posix.iovec{ .base = &buffer_read, .len = buffer_read.len },
};
const sqe_writev = try ring.writev(0xdddddddd, fd, iovecs_write[0..], 17);
@@ -1995,8 +1995,8 @@ test "write_fixed/read_fixed" {
raw_buffers[0][0.."foobar".len].* = "foobar".*;
var buffers = [2]posix.iovec{
.{ .iov_base = &raw_buffers[0], .iov_len = raw_buffers[0].len },
.{ .iov_base = &raw_buffers[1], .iov_len = raw_buffers[1].len },
.{ .base = &raw_buffers[0], .len = raw_buffers[0].len },
.{ .base = &raw_buffers[1], .len = raw_buffers[1].len },
};
ring.register_buffers(&buffers) catch |err| switch (err) {
error.SystemResources => {
@@ -2022,18 +2022,18 @@ test "write_fixed/read_fixed" {
try testing.expectEqual(linux.io_uring_cqe{
.user_data = 0x45454545,
.res = @as(i32, @intCast(buffers[0].iov_len)),
.res = @as(i32, @intCast(buffers[0].len)),
.flags = 0,
}, cqe_write);
try testing.expectEqual(linux.io_uring_cqe{
.user_data = 0x12121212,
.res = @as(i32, @intCast(buffers[1].iov_len)),
.res = @as(i32, @intCast(buffers[1].len)),
.flags = 0,
}, cqe_read);
try testing.expectEqualSlices(u8, "\x00\x00\x00", buffers[1].iov_base[0..3]);
try testing.expectEqualSlices(u8, "foobar", buffers[1].iov_base[3..9]);
try testing.expectEqualSlices(u8, "zz", buffers[1].iov_base[9..11]);
try testing.expectEqualSlices(u8, "\x00\x00\x00", buffers[1].base[0..3]);
try testing.expectEqualSlices(u8, "foobar", buffers[1].base[3..9]);
try testing.expectEqualSlices(u8, "zz", buffers[1].base[9..11]);
}
test "openat" {
@@ -2189,7 +2189,7 @@ test "sendmsg/recvmsg" {
const buffer_send = [_]u8{42} ** 128;
const iovecs_send = [_]posix.iovec_const{
posix.iovec_const{ .iov_base = &buffer_send, .iov_len = buffer_send.len },
posix.iovec_const{ .base = &buffer_send, .len = buffer_send.len },
};
const msg_send: posix.msghdr_const = .{
.name = &address_server.any,
@@ -2207,7 +2207,7 @@ test "sendmsg/recvmsg" {
var buffer_recv = [_]u8{0} ** 128;
var iovecs_recv = [_]posix.iovec{
posix.iovec{ .iov_base = &buffer_recv, .iov_len = buffer_recv.len },
posix.iovec{ .base = &buffer_recv, .len = buffer_recv.len },
};
const addr = [_]u8{0} ** 4;
var address_recv = net.Address.initIp4(addr, 0);

4
lib/std/os/linux/io_uring_sqe.zig
View File

@@ -117,12 +117,12 @@ pub const io_uring_sqe = extern struct {
}
pub fn prep_read_fixed(sqe: *linux.io_uring_sqe, fd: linux.fd_t, buffer: *std.posix.iovec, offset: u64, buffer_index: u16) void {
sqe.prep_rw(.READ_FIXED, fd, @intFromPtr(buffer.iov_base), buffer.iov_len, offset);
sqe.prep_rw(.READ_FIXED, fd, @intFromPtr(buffer.base), buffer.len, offset);
sqe.buf_index = buffer_index;
}
pub fn prep_write_fixed(sqe: *linux.io_uring_sqe, fd: linux.fd_t, buffer: *std.posix.iovec, offset: u64, buffer_index: u16) void {
sqe.prep_rw(.WRITE_FIXED, fd, @intFromPtr(buffer.iov_base), buffer.iov_len, offset);
sqe.prep_rw(.WRITE_FIXED, fd, @intFromPtr(buffer.base), buffer.len, offset);
sqe.buf_index = buffer_index;
}

34
lib/std/posix.zig
View File

@@ -173,13 +173,13 @@ pub const W_OK = system.W_OK;
pub const X_OK = system.X_OK;
pub const iovec = extern struct {
iov_base: [*]u8,
iov_len: usize,
base: [*]u8,
len: usize,
};
pub const iovec_const = extern struct {
iov_base: [*]const u8,
iov_len: usize,
base: [*]const u8,
len: usize,
};
pub const ACCMODE = enum(u2) {
@@ -796,8 +796,8 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
}
if (native_os == .wasi and !builtin.link_libc) {
const iovs = [1]iovec{iovec{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
}};
var nread: usize = undefined;
@@ -865,7 +865,7 @@ pub fn readv(fd: fd_t, iov: []const iovec) ReadError!usize {
// TODO improve this to use ReadFileScatter
if (iov.len == 0) return 0;
const first = iov[0];
return read(fd, first.iov_base[0..first.iov_len]);
return read(fd, first.base[0..first.len]);
}
if (native_os == .wasi and !builtin.link_libc) {
var nread: usize = undefined;
@@ -932,8 +932,8 @@ pub fn pread(fd: fd_t, buf: []u8, offset: u64) PReadError!usize {
}
if (native_os == .wasi and !builtin.link_libc) {
const iovs = [1]iovec{iovec{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
}};
var nread: usize = undefined;
@@ -1077,7 +1077,7 @@ pub fn preadv(fd: fd_t, iov: []const iovec, offset: u64) PReadError!usize {
// So we simply read into the first vector only.
if (iov.len == 0) return 0;
const first = iov[0];
return pread(fd, first.iov_base[0..first.iov_len], offset);
return pread(fd, first.base[0..first.len], offset);
}
if (native_os == .wasi and !builtin.link_libc) {
var nread: usize = undefined;
@@ -1186,8 +1186,8 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {
if (native_os == .wasi and !builtin.link_libc) {
const ciovs = [_]iovec_const{iovec_const{
.iov_base = bytes.ptr,
.iov_len = bytes.len,
.base = bytes.ptr,
.len = bytes.len,
}};
var nwritten: usize = undefined;
switch (wasi.fd_write(fd, &ciovs, ciovs.len, &nwritten)) {
@@ -1263,7 +1263,7 @@ pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!usize {
// TODO improve this to use WriteFileScatter
if (iov.len == 0) return 0;
const first = iov[0];
return write(fd, first.iov_base[0..first.iov_len]);
return write(fd, first.base[0..first.len]);
}
if (native_os == .wasi and !builtin.link_libc) {
var nwritten: usize = undefined;
@@ -1340,8 +1340,8 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {
}
if (native_os == .wasi and !builtin.link_libc) {
const ciovs = [1]iovec_const{iovec_const{
.iov_base = bytes.ptr,
.iov_len = bytes.len,
.base = bytes.ptr,
.len = bytes.len,
}};
var nwritten: usize = undefined;
@@ -1432,7 +1432,7 @@ pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) PWriteError!usiz
// So we simply write the first vector only.
if (iov.len == 0) return 0;
const first = iov[0];
return pwrite(fd, first.iov_base[0..first.iov_len], offset);
return pwrite(fd, first.base[0..first.len], offset);
}
if (native_os == .wasi and !builtin.link_libc) {
var nwritten: usize = undefined;
@@ -6361,7 +6361,7 @@ pub fn sendfile(
fn count_iovec_bytes(iovs: []const iovec_const) usize {
var count: usize = 0;
for (iovs) |iov| {
count += iov.iov_len;
count += iov.len;
}
return count;
}

2
lib/std/posix/test.zig
View File

@@ -939,7 +939,7 @@ test "writev longer than IOV_MAX" {
var file = try tmp.dir.createFile("pwritev", .{});
defer file.close();
const iovecs = [_]posix.iovec_const{.{ .iov_base = "a", .iov_len = 1 }} ** (posix.IOV_MAX + 1);
const iovecs = [_]posix.iovec_const{.{ .base = "a", .len = 1 }} ** (posix.IOV_MAX + 1);
const amt = try file.writev(&iovecs);
try testing.expectEqual(@as(usize, posix.IOV_MAX), amt);
}

8
lib/std/zig/Server.zig
View File

@@ -149,13 +149,13 @@ pub fn serveMessage(
var iovecs: [10]std.posix.iovec_const = undefined;
const header_le = bswap(header);
iovecs[0] = .{
.iov_base = @as([*]const u8, @ptrCast(&header_le)),
.iov_len = @sizeOf(OutMessage.Header),
.base = @as([*]const u8, @ptrCast(&header_le)),
.len = @sizeOf(OutMessage.Header),
};
for (bufs, iovecs[1 .. bufs.len + 1]) |buf, *iovec| {
iovec.* = .{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
};
}
try s.out.writevAll(iovecs[0 .. bufs.len + 1]);

8
src/Compilation.zig
View File

@@ -2811,8 +2811,8 @@ fn addBuf(bufs_list: []std.posix.iovec_const, bufs_len: *usize, buf: []const u8)
const i = bufs_len.*;
bufs_len.* = i + 1;
bufs_list[i] = .{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
};
}
@@ -3800,8 +3800,8 @@ fn docsCopyModule(comp: *Compilation, module: *Package.Module, name: []const u8,
};
var header_and_trailer: [2]std.posix.iovec_const = .{
.{ .iov_base = header_bytes.ptr, .iov_len = header_bytes.len },
.{ .iov_base = padding.ptr, .iov_len = padding.len },
.{ .base = header_bytes.ptr, .len = header_bytes.len },
.{ .base = padding.ptr, .len = padding.len },
};
try tar_file.writeFileAll(file, .{

36
src/Module.zig
View File

@@ -2336,24 +2336,24 @@ pub fn astGenFile(mod: *Module, file: *File) !void {
};
var iovecs = [_]std.posix.iovec_const{
.{
.iov_base = @as([*]const u8, @ptrCast(&header)),
.iov_len = @sizeOf(Zir.Header),
.base = @as([*]const u8, @ptrCast(&header)),
.len = @sizeOf(Zir.Header),
},
.{
.iov_base = @as([*]const u8, @ptrCast(file.zir.instructions.items(.tag).ptr)),
.iov_len = file.zir.instructions.len,
.base = @as([*]const u8, @ptrCast(file.zir.instructions.items(.tag).ptr)),
.len = file.zir.instructions.len,
},
.{
.iov_base = data_ptr,
.iov_len = file.zir.instructions.len * 8,
.base = data_ptr,
.len = file.zir.instructions.len * 8,
},
.{
.iov_base = file.zir.string_bytes.ptr,
.iov_len = file.zir.string_bytes.len,
.base = file.zir.string_bytes.ptr,
.len = file.zir.string_bytes.len,
},
.{
.iov_base = @as([*]const u8, @ptrCast(file.zir.extra.ptr)),
.iov_len = file.zir.extra.len * 4,
.base = @as([*]const u8, @ptrCast(file.zir.extra.ptr)),
.len = file.zir.extra.len * 4,
},
};
cache_file.writevAll(&iovecs) catch |err| {
@@ -2424,20 +2424,20 @@ fn loadZirCacheBody(gpa: Allocator, header: Zir.Header, cache_file: std.fs.File)
var iovecs = [_]std.posix.iovec{
.{
.iov_base = @as([*]u8, @ptrCast(zir.instructions.items(.tag).ptr)),
.iov_len = header.instructions_len,
.base = @as([*]u8, @ptrCast(zir.instructions.items(.tag).ptr)),
.len = header.instructions_len,
},
.{
.iov_base = data_ptr,
.iov_len = header.instructions_len * 8,
.base = data_ptr,
.len = header.instructions_len * 8,
},
.{
.iov_base = zir.string_bytes.ptr,
.iov_len = header.string_bytes_len,
.base = zir.string_bytes.ptr,
.len = header.string_bytes_len,
},
.{
.iov_base = @as([*]u8, @ptrCast(zir.extra.ptr)),
.iov_len = header.extra_len * 4,
.base = @as([*]u8, @ptrCast(zir.extra.ptr)),
.len = header.extra_len * 4,
},
};
const amt_read = try cache_file.readvAll(&iovecs);

18
src/link/C.zig
View File

@@ -483,15 +483,15 @@ pub fn flushModule(self: *C, arena: Allocator, prog_node: *std.Progress.Node) !v
}
f.all_buffers.items[ctypes_index] = .{
.iov_base = if (f.ctypes_buf.items.len > 0) f.ctypes_buf.items.ptr else "",
.iov_len = f.ctypes_buf.items.len,
.base = if (f.ctypes_buf.items.len > 0) f.ctypes_buf.items.ptr else "",
.len = f.ctypes_buf.items.len,
};
f.file_size += f.ctypes_buf.items.len;
const lazy_fwd_decl_len = self.lazy_fwd_decl_buf.items.len;
f.all_buffers.items[lazy_index] = .{
.iov_base = if (lazy_fwd_decl_len > 0) self.lazy_fwd_decl_buf.items.ptr else "",
.iov_len = lazy_fwd_decl_len,
.base = if (lazy_fwd_decl_len > 0) self.lazy_fwd_decl_buf.items.ptr else "",
.len = lazy_fwd_decl_len,
};
f.file_size += lazy_fwd_decl_len;
@@ -527,7 +527,7 @@ const Flush = struct {
fn appendBufAssumeCapacity(f: *Flush, buf: []const u8) void {
if (buf.len == 0) return;
f.all_buffers.appendAssumeCapacity(.{ .iov_base = buf.ptr, .iov_len = buf.len });
f.all_buffers.appendAssumeCapacity(.{ .base = buf.ptr, .len = buf.len });
f.file_size += buf.len;
}
@@ -747,8 +747,8 @@ pub fn flushEmitH(zcu: *Zcu) !void {
var file_size: u64 = zig_h.len;
if (zig_h.len != 0) {
all_buffers.appendAssumeCapacity(.{
.iov_base = zig_h,
.iov_len = zig_h.len,
.base = zig_h,
.len = zig_h.len,
});
}
@@ -757,8 +757,8 @@ pub fn flushEmitH(zcu: *Zcu) !void {
const buf = decl_emit_h.fwd_decl.items;
if (buf.len != 0) {
all_buffers.appendAssumeCapacity(.{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
});
file_size += buf.len;
}

52
src/link/Dwarf.zig
View File

@@ -2120,32 +2120,32 @@ fn pwriteDbgLineNops(
var padding_left = prev_padding_size;
if (padding_left % 2 != 0) {
vecs[vec_index] = .{
.iov_base = &three_byte_nop,
.iov_len = three_byte_nop.len,
.base = &three_byte_nop,
.len = three_byte_nop.len,
};
vec_index += 1;
padding_left -= three_byte_nop.len;
}
while (padding_left > page_of_nops.len) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = page_of_nops.len,
.base = &page_of_nops,
.len = page_of_nops.len,
};
vec_index += 1;
padding_left -= page_of_nops.len;
}
if (padding_left > 0) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = padding_left,
.base = &page_of_nops,
.len = padding_left,
};
vec_index += 1;
}
}
vecs[vec_index] = .{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
};
if (buf.len > 0) vec_index += 1;
@@ -2153,24 +2153,24 @@ fn pwriteDbgLineNops(
var padding_left = next_padding_size;
if (padding_left % 2 != 0) {
vecs[vec_index] = .{
.iov_base = &three_byte_nop,
.iov_len = three_byte_nop.len,
.base = &three_byte_nop,
.len = three_byte_nop.len,
};
vec_index += 1;
padding_left -= three_byte_nop.len;
}
while (padding_left > page_of_nops.len) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = page_of_nops.len,
.base = &page_of_nops,
.len = page_of_nops.len,
};
vec_index += 1;
padding_left -= page_of_nops.len;
}
if (padding_left > 0) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = padding_left,
.base = &page_of_nops,
.len = padding_left,
};
vec_index += 1;
}
@@ -2237,24 +2237,24 @@ fn pwriteDbgInfoNops(
var padding_left = prev_padding_size;
while (padding_left > page_of_nops.len) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = page_of_nops.len,
.base = &page_of_nops,
.len = page_of_nops.len,
};
vec_index += 1;
padding_left -= page_of_nops.len;
}
if (padding_left > 0) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = padding_left,
.base = &page_of_nops,
.len = padding_left,
};
vec_index += 1;
}
}
vecs[vec_index] = .{
.iov_base = buf.ptr,
.iov_len = buf.len,
.base = buf.ptr,
.len = buf.len,
};
if (buf.len > 0) vec_index += 1;
@@ -2262,16 +2262,16 @@ fn pwriteDbgInfoNops(
var padding_left = next_padding_size;
while (padding_left > page_of_nops.len) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = page_of_nops.len,
.base = &page_of_nops,
.len = page_of_nops.len,
};
vec_index += 1;
padding_left -= page_of_nops.len;
}
if (padding_left > 0) {
vecs[vec_index] = .{
.iov_base = &page_of_nops,
.iov_len = padding_left,
.base = &page_of_nops,
.len = padding_left,
};
vec_index += 1;
}
@@ -2280,8 +2280,8 @@ fn pwriteDbgInfoNops(
if (trailing_zero) {
var zbuf = [1]u8{0};
vecs[vec_index] = .{
.iov_base = &zbuf,
.iov_len = zbuf.len,
.base = &zbuf,
.len = zbuf.len,
};
vec_index += 1;
}

8
src/link/Elf/ZigObject.zig
View File

@@ -965,12 +965,12 @@ fn updateDeclCode(
switch (builtin.os.tag) {
.linux => {
var code_vec: [1]std.posix.iovec_const = .{.{
.iov_base = code.ptr,
.iov_len = code.len,
.base = code.ptr,
.len = code.len,
}};
var remote_vec: [1]std.posix.iovec_const = .{.{
.iov_base = @as([*]u8, @ptrFromInt(@as(usize, @intCast(sym.address(.{}, elf_file))))),
.iov_len = code.len,
.base = @as([*]u8, @ptrFromInt(@as(usize, @intCast(sym.address(.{}, elf_file))))),
.len = code.len,
}};
const rc = std.os.linux.process_vm_writev(pid, &code_vec, &remote_vec, 0);
switch (std.os.linux.E.init(rc)) {

8
src/link/Elf/synthetic_sections.zig
View File

@@ -314,12 +314,12 @@ pub const ZigGotSection = struct {
switch (builtin.os.tag) {
.linux => {
var local_vec: [1]std.posix.iovec_const = .{.{
.iov_base = &buf,
.iov_len = buf.len,
.base = &buf,
.len = buf.len,
}};
var remote_vec: [1]std.posix.iovec_const = .{.{
.iov_base = @as([*]u8, @ptrFromInt(@as(usize, @intCast(vaddr)))),
.iov_len = buf.len,
.base = @as([*]u8, @ptrFromInt(@as(usize, @intCast(vaddr)))),
.len = buf.len,
}};
const rc = std.os.linux.process_vm_writev(pid, &local_vec, &remote_vec, 0);
switch (std.os.linux.E.init(rc)) {

20
src/link/Plan9.zig
View File

@@ -728,7 +728,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const hdr_size = if (self.sixtyfour_bit) @as(usize, 40) else 32;
const hdr_slice: []u8 = hdr_buf[0..hdr_size];
var foff = hdr_size;
iovecs[0] = .{ .iov_base = hdr_slice.ptr, .iov_len = hdr_slice.len };
iovecs[0] = .{ .base = hdr_slice.ptr, .len = hdr_slice.len };
var iovecs_i: usize = 1;
var text_i: u64 = 0;
@@ -757,7 +757,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
linecount = out.end_line;
}
foff += out.code.len;
iovecs[iovecs_i] = .{ .iov_base = out.code.ptr, .iov_len = out.code.len };
iovecs[iovecs_i] = .{ .base = out.code.ptr, .len = out.code.len };
iovecs_i += 1;
const off = self.getAddr(text_i, .t);
text_i += out.code.len;
@@ -787,7 +787,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const text_atom = if (meta.text_state != .unused) self.getAtomPtr(meta.text_atom) else continue;
const code = text_atom.code.getOwnedCode().?;
foff += code.len;
iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len };
iovecs_i += 1;
const off = self.getAddr(text_i, .t);
text_i += code.len;
@@ -812,7 +812,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
}
}
// global offset table is in data
iovecs[iovecs_i] = .{ .iov_base = got_table.ptr, .iov_len = got_table.len };
iovecs[iovecs_i] = .{ .base = got_table.ptr, .len = got_table.len };
iovecs_i += 1;
// data
var data_i: u64 = got_size;
@@ -824,7 +824,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const code = entry.value_ptr.*;
foff += code.len;
iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len };
iovecs_i += 1;
const off = self.getAddr(data_i, .d);
data_i += code.len;
@@ -847,7 +847,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const code = atom.code.getOwnedCode().?; // unnamed consts must own their code
log.debug("write unnamed const: ({s})", .{self.syms.items[atom.sym_index.?].name});
foff += code.len;
iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len };
iovecs_i += 1;
const off = self.getAddr(data_i, .d);
data_i += code.len;
@@ -868,7 +868,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const code = atom.code.getOwnedCode().?;
log.debug("write anon decl: {s}", .{self.syms.items[atom.sym_index.?].name});
foff += code.len;
iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len };
iovecs_i += 1;
const off = self.getAddr(data_i, .d);
data_i += code.len;
@@ -888,7 +888,7 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const data_atom = if (meta.rodata_state != .unused) self.getAtomPtr(meta.rodata_atom) else continue;
const code = data_atom.code.getOwnedCode().?; // lazy symbols must own their code
foff += code.len;
iovecs[iovecs_i] = .{ .iov_base = code.ptr, .iov_len = code.len };
iovecs[iovecs_i] = .{ .base = code.ptr, .len = code.len };
iovecs_i += 1;
const off = self.getAddr(data_i, .d);
data_i += code.len;
@@ -929,9 +929,9 @@ pub fn flushModule(self: *Plan9, arena: Allocator, prog_node: *std.Progress.Node
const syms = try sym_buf.toOwnedSlice();
defer gpa.free(syms);
assert(2 + self.atomCount() - self.externCount() == iovecs_i); // we didn't write all the decls
iovecs[iovecs_i] = .{ .iov_base = syms.ptr, .iov_len = syms.len };
iovecs[iovecs_i] = .{ .base = syms.ptr, .len = syms.len };
iovecs_i += 1;
iovecs[iovecs_i] = .{ .iov_base = linecountinfo.items.ptr, .iov_len = linecountinfo.items.len };
iovecs[iovecs_i] = .{ .base = linecountinfo.items.ptr, .len = linecountinfo.items.len };
iovecs_i += 1;
// generate the header
self.hdr = .{

4
src/link/Wasm.zig
View File

@@ -3047,8 +3047,8 @@ fn writeToFile(
// finally, write the entire binary into the file.
var iovec = [_]std.posix.iovec_const{.{
.iov_base = binary_bytes.items.ptr,
.iov_len = binary_bytes.items.len,
.base = binary_bytes.items.ptr,
.len = binary_bytes.items.len,
}};
try wasm.base.file.?.writevAll(&iovec);
}