authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-09-26 11:06:09-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-09-26 11:06:09-04:00
log9485043b3c445a3153e61c0bbc908486134d564a
tree9a8d9f36bd6b445e49e166aaf716d9559d4538c8
parent7b204649e3af348a7831837d5a36219733b505ca
signaturelock-open Commit is signed but in an unrecognized format.

fix implicit casting to *c_void

closes #1588 also some small std lib changes regarding posix sockets and one doc typo fix

7 files changed, 155 insertions(+), 47 deletions(-)

doc/langref.html.in+1-1
......@@ -587,7 +587,7 @@ const c_string_literal =
587587;
588588 {#code_end#}
589589 <p>
590 In this example the variable {#syntax#}c_string_literal{#endsyntax#} has type {#syntax#}[*]const char{#endsyntax#} and
590 In this example the variable {#syntax#}c_string_literal{#endsyntax#} has type {#syntax#}[*]const u8{#endsyntax#} and
591591 has a terminating null byte.
592592 </p>
593593 {#see_also|@embedFile#}
src/ir.cpp+73-41
......@@ -155,6 +155,8 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
155155static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val);
156156static Error ir_read_const_ptr(IrAnalyze *ira, AstNode *source_node,
157157 ConstExprValue *out_val, ConstExprValue *ptr_val);
158static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr,
159 ZigType *dest_type, IrInstruction *dest_type_src);
158160
159161static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *const_val) {
160162 assert(get_src_ptr_type(const_val->type) != nullptr);
......@@ -8573,17 +8575,6 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
85738575 return result;
85748576 }
85758577
8576 // *T and [*]T can always cast to *c_void
8577 if (wanted_type->id == ZigTypeIdPointer &&
8578 wanted_type->data.pointer.ptr_len == PtrLenSingle &&
8579 wanted_type->data.pointer.child_type == g->builtin_types.entry_c_void &&
8580 actual_type->id == ZigTypeIdPointer &&
8581 (!actual_type->data.pointer.is_const || wanted_type->data.pointer.is_const) &&
8582 (!actual_type->data.pointer.is_volatile || wanted_type->data.pointer.is_volatile))
8583 {
8584 return result;
8585 }
8586
85878578 // pointer const
85888579 if (wanted_type->id == ZigTypeIdPointer && actual_type->id == ZigTypeIdPointer) {
85898580 ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
......@@ -11156,6 +11147,33 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1115611147 }
1115711148 }
1115811149
11150 // cast from *T and [*]T to *c_void and ?*c_void
11151 // but don't do it if the actual type is a double pointer
11152 if (actual_type->id == ZigTypeIdPointer && actual_type->data.pointer.child_type->id != ZigTypeIdPointer) {
11153 ZigType *dest_ptr_type = nullptr;
11154 if (wanted_type->id == ZigTypeIdPointer &&
11155 wanted_type->data.pointer.ptr_len == PtrLenSingle &&
11156 wanted_type->data.pointer.child_type == ira->codegen->builtin_types.entry_c_void)
11157 {
11158 dest_ptr_type = wanted_type;
11159 } else if (wanted_type->id == ZigTypeIdOptional &&
11160 wanted_type->data.maybe.child_type->id == ZigTypeIdPointer &&
11161 wanted_type->data.maybe.child_type->data.pointer.ptr_len == PtrLenSingle &&
11162 wanted_type->data.maybe.child_type->data.pointer.child_type == ira->codegen->builtin_types.entry_c_void)
11163 {
11164 dest_ptr_type = wanted_type->data.maybe.child_type;
11165 }
11166 if (dest_ptr_type != nullptr &&
11167 (!actual_type->data.pointer.is_const || dest_ptr_type->data.pointer.is_const) &&
11168 (!actual_type->data.pointer.is_volatile || dest_ptr_type->data.pointer.is_volatile) &&
11169 actual_type->data.pointer.bit_offset == dest_ptr_type->data.pointer.bit_offset &&
11170 actual_type->data.pointer.unaligned_bit_count == dest_ptr_type->data.pointer.unaligned_bit_count &&
11171 get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, dest_ptr_type))
11172 {
11173 return ir_analyze_ptr_cast(ira, source_instr, value, wanted_type, source_instr);
11174 }
11175 }
11176
1115911177 // cast from T to *T where T is zero bits
1116011178 if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
1116111179 types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
......@@ -20234,79 +20252,75 @@ static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint3
2023420252 return result;
2023520253}
2023620254
20237static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
20255static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr,
20256 ZigType *dest_type, IrInstruction *dest_type_src)
20257{
2023820258 Error err;
2023920259
20240 IrInstruction *dest_type_value = instruction->dest_type->other;
20241 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
20242 if (type_is_invalid(dest_type))
20243 return ira->codegen->builtin_types.entry_invalid;
20244
20245 IrInstruction *ptr = instruction->ptr->other;
2024620260 ZigType *src_type = ptr->value.type;
20247 if (type_is_invalid(src_type))
20248 return ira->codegen->builtin_types.entry_invalid;
20261 assert(!type_is_invalid(src_type));
2024920262
2025020263 // We have a check for zero bits later so we use get_src_ptr_type to
2025120264 // validate src_type and dest_type.
2025220265
2025320266 if (get_src_ptr_type(src_type) == nullptr) {
2025420267 ir_add_error(ira, ptr, buf_sprintf("expected pointer, found '%s'", buf_ptr(&src_type->name)));
20255 return ira->codegen->builtin_types.entry_invalid;
20268 return ira->codegen->invalid_instruction;
2025620269 }
2025720270
2025820271 if (get_src_ptr_type(dest_type) == nullptr) {
20259 ir_add_error(ira, dest_type_value,
20272 ir_add_error(ira, dest_type_src,
2026020273 buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
20261 return ira->codegen->builtin_types.entry_invalid;
20274 return ira->codegen->invalid_instruction;
2026220275 }
2026320276
2026420277 if (get_ptr_const(src_type) && !get_ptr_const(dest_type)) {
20265 ir_add_error(ira, &instruction->base, buf_sprintf("cast discards const qualifier"));
20266 return ira->codegen->builtin_types.entry_invalid;
20278 ir_add_error(ira, source_instr, buf_sprintf("cast discards const qualifier"));
20279 return ira->codegen->invalid_instruction;
2026720280 }
2026820281
2026920282 if (instr_is_comptime(ptr)) {
2027020283 ConstExprValue *val = ir_resolve_const(ira, ptr, UndefOk);
2027120284 if (!val)
20272 return ira->codegen->builtin_types.entry_invalid;
20285 return ira->codegen->invalid_instruction;
2027320286
20274 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20275 copy_const_val(out_val, val, false);
20276 out_val->type = dest_type;
20277 return dest_type;
20287 IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope, source_instr->source_node,
20288 dest_type);
20289 copy_const_val(&result->value, val, false);
20290 result->value.type = dest_type;
20291 return result;
2027820292 }
2027920293
2028020294 uint32_t src_align_bytes;
2028120295 if ((err = resolve_ptr_align(ira, src_type, &src_align_bytes)))
20282 return ira->codegen->builtin_types.entry_invalid;
20296 return ira->codegen->invalid_instruction;
2028320297
2028420298 uint32_t dest_align_bytes;
2028520299 if ((err = resolve_ptr_align(ira, dest_type, &dest_align_bytes)))
20286 return ira->codegen->builtin_types.entry_invalid;
20300 return ira->codegen->invalid_instruction;
2028720301
2028820302 if (dest_align_bytes > src_align_bytes) {
20289 ErrorMsg *msg = ir_add_error(ira, &instruction->base, buf_sprintf("cast increases pointer alignment"));
20303 ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
2029020304 add_error_note(ira->codegen, msg, ptr->source_node,
2029120305 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&src_type->name), src_align_bytes));
20292 add_error_note(ira->codegen, msg, dest_type_value->source_node,
20306 add_error_note(ira->codegen, msg, dest_type_src->source_node,
2029320307 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&dest_type->name), dest_align_bytes));
20294 return ira->codegen->builtin_types.entry_invalid;
20308 return ira->codegen->invalid_instruction;
2029520309 }
2029620310
20297 IrInstruction *casted_ptr = ir_build_ptr_cast(&ira->new_irb, instruction->base.scope,
20298 instruction->base.source_node, nullptr, ptr);
20311 IrInstruction *casted_ptr = ir_build_ptr_cast(&ira->new_irb, source_instr->scope,
20312 source_instr->source_node, nullptr, ptr);
2029920313 casted_ptr->value.type = dest_type;
2030020314
2030120315 if (type_has_bits(dest_type) && !type_has_bits(src_type)) {
20302 ErrorMsg *msg = ir_add_error(ira, &instruction->base,
20316 ErrorMsg *msg = ir_add_error(ira, source_instr,
2030320317 buf_sprintf("'%s' and '%s' do not have the same in-memory representation",
2030420318 buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
2030520319 add_error_note(ira->codegen, msg, ptr->source_node,
2030620320 buf_sprintf("'%s' has no in-memory bits", buf_ptr(&src_type->name)));
20307 add_error_note(ira->codegen, msg, dest_type_value->source_node,
20321 add_error_note(ira->codegen, msg, dest_type_src->source_node,
2030820322 buf_sprintf("'%s' has in-memory bits", buf_ptr(&dest_type->name)));
20309 return ira->codegen->builtin_types.entry_invalid;
20323 return ira->codegen->invalid_instruction;
2031020324 }
2031120325
2031220326 // Keep the bigger alignment, it can only help-
......@@ -20315,10 +20329,28 @@ static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtr
2031520329 if (src_align_bytes > dest_align_bytes && type_has_bits(dest_type)) {
2031620330 result = ir_align_cast(ira, casted_ptr, src_align_bytes, false);
2031720331 if (type_is_invalid(result->value.type))
20318 return ira->codegen->builtin_types.entry_invalid;
20332 return ira->codegen->invalid_instruction;
2031920333 } else {
2032020334 result = casted_ptr;
2032120335 }
20336 return result;
20337}
20338
20339static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
20340 IrInstruction *dest_type_value = instruction->dest_type->other;
20341 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
20342 if (type_is_invalid(dest_type))
20343 return ira->codegen->builtin_types.entry_invalid;
20344
20345 IrInstruction *ptr = instruction->ptr->other;
20346 ZigType *src_type = ptr->value.type;
20347 if (type_is_invalid(src_type))
20348 return ira->codegen->builtin_types.entry_invalid;
20349
20350 IrInstruction *result = ir_analyze_ptr_cast(ira, &instruction->base, ptr, dest_type, dest_type_value);
20351 if (type_is_invalid(result->value.type))
20352 return ira->codegen->builtin_types.entry_invalid;
20353
2032220354 ir_link_new_instruction(result, &instruction->base);
2032320355 return result->value.type;
2032420356}
std/event/tcp.zig+49-1
......@@ -110,13 +110,61 @@ pub const Server = struct {
110110 }
111111};
112112
113pub async fn connectUnixSocket(loop: *Loop, path: []const u8) !i32 {
114 const sockfd = try std.os.posixSocket(
115 posix.AF_UNIX,
116 posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK,
117 0,
118 );
119 errdefer std.os.close(sockfd);
120
121 var sock_addr = posix.sockaddr{
122 .un = posix.sockaddr_un{
123 .family = posix.AF_UNIX,
124 .path = undefined,
125 },
126 };
127
128 if (path.len > @typeOf(sock_addr.un.path).len) return error.NameTooLong;
129 mem.copy(u8, sock_addr.un.path[0..], path);
130 const size = @intCast(u32, @sizeOf(posix.sa_family_t) + path.len);
131 try std.os.posixConnectAsync(sockfd, &sock_addr, size);
132 try await try async loop.linuxWaitFd(sockfd, posix.EPOLLIN | posix.EPOLLOUT | posix.EPOLLET);
133 try std.os.posixGetSockOptConnectError(sockfd);
134
135 return sockfd;
136}
137
138pub async fn socketRead(loop: *std.event.Loop, fd: i32, buffer: []u8) !void {
139 while (true) {
140 return std.os.posixRead(fd, buffer) catch |err| switch (err) {
141 error.WouldBlock => {
142 try await try async loop.linuxWaitFd(fd, std.os.posix.EPOLLET | std.os.posix.EPOLLIN);
143 continue;
144 },
145 else => return err,
146 };
147 }
148}
149pub async fn socketWrite(loop: *std.event.Loop, fd: i32, buffer: []const u8) !void {
150 while (true) {
151 return std.os.posixWrite(fd, buffer) catch |err| switch (err) {
152 error.WouldBlock => {
153 try await try async loop.linuxWaitFd(fd, std.os.posix.EPOLLET | std.os.posix.EPOLLOUT);
154 continue;
155 },
156 else => return err,
157 };
158 }
159}
160
113161pub async fn connect(loop: *Loop, _address: *const std.net.Address) !std.os.File {
114162 var address = _address.*; // TODO https://github.com/ziglang/zig/issues/733
115163
116164 const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM | posix.SOCK_CLOEXEC | posix.SOCK_NONBLOCK, posix.PROTO_tcp);
117165 errdefer std.os.close(sockfd);
118166
119 try std.os.posixConnectAsync(sockfd, &address.os_addr);
167 try std.os.posixConnectAsync(sockfd, &address.os_addr, @sizeOf(posix.sockaddr_in));
120168 try await try async loop.linuxWaitFd(sockfd, posix.EPOLLIN | posix.EPOLLOUT | posix.EPOLLET);
121169 try std.os.posixGetSockOptConnectError(sockfd);
122170
std/os/index.zig+2-2
......@@ -2677,9 +2677,9 @@ pub fn posixConnect(sockfd: i32, sockaddr: *const posix.sockaddr) PosixConnectEr
26772677
26782678/// Same as posixConnect except it is for blocking socket file descriptors.
26792679/// It expects to receive EINPROGRESS.
2680pub fn posixConnectAsync(sockfd: i32, sockaddr: *const posix.sockaddr) PosixConnectError!void {
2680pub fn posixConnectAsync(sockfd: i32, sockaddr: *const c_void, len: u32) PosixConnectError!void {
26812681 while (true) {
2682 const rc = posix.connect(sockfd, sockaddr, @sizeOf(posix.sockaddr));
2682 const rc = posix.connect(sockfd, sockaddr, len);
26832683 const err = posix.getErrno(rc);
26842684 switch (err) {
26852685 0, posix.EINPROGRESS => return,
std/os/linux/index.zig+8-2
......@@ -1094,6 +1094,7 @@ pub const in_port_t = u16;
10941094pub const sa_family_t = u16;
10951095pub const socklen_t = u32;
10961096
1097/// This intentionally only has ip4 and ip6
10971098pub const sockaddr = extern union {
10981099 in: sockaddr_in,
10991100 in6: sockaddr_in6,
......@@ -1114,6 +1115,11 @@ pub const sockaddr_in6 = extern struct {
11141115 scope_id: u32,
11151116};
11161117
1118pub const sockaddr_un = extern struct {
1119 family: sa_family_t,
1120 path: [108]u8,
1121};
1122
11171123pub const iovec = extern struct {
11181124 iov_base: [*]u8,
11191125 iov_len: usize,
......@@ -1148,8 +1154,8 @@ pub fn sendmsg(fd: i32, msg: *const msghdr, flags: u32) usize {
11481154 return syscall3(SYS_sendmsg, @intCast(usize, fd), @ptrToInt(msg), flags);
11491155}
11501156
1151pub fn connect(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
1152 return syscall3(SYS_connect, @intCast(usize, fd), @ptrToInt(addr), @intCast(usize, len));
1157pub fn connect(fd: i32, addr: *const c_void, len: socklen_t) usize {
1158 return syscall3(SYS_connect, @intCast(usize, fd), @ptrToInt(addr), len);
11531159}
11541160
11551161pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
test/cases/cast.zig+10
......@@ -537,3 +537,13 @@ pub const PFN_void = extern fn (*c_void) void;
537537fn foobar(func: PFN_void) void {
538538 std.debug.assert(@ptrToInt(func) == @maxValue(usize));
539539}
540
541test "implicit ptr to *c_void" {
542 var a: u32 = 1;
543 var ptr: *c_void = &a;
544 var b: *u32 = @ptrCast(*u32, ptr);
545 assert(b.* == 1);
546 var ptr2: ?*c_void = &a;
547 var c: *u32 = @ptrCast(*u32, ptr2.?);
548 assert(c.* == 1);
549}
test/compile_errors.zig+12
......@@ -1,6 +1,18 @@
11const tests = @import("tests.zig");
22
33pub fn addCases(cases: *tests.CompileErrorContext) void {
4 cases.add(
5 "don't implicit cast double pointer to *c_void",
6 \\export fn entry() void {
7 \\ var a: u32 = 1;
8 \\ var ptr: *c_void = &a;
9 \\ var b: *u32 = @ptrCast(*u32, ptr);
10 \\ var ptr2: *c_void = &b;
11 \\}
12 ,
13 ".tmp_source.zig:5:26: error: expected type '*c_void', found '**u32'",
14 );
15
416 cases.add(
517 "runtime index into comptime type slice",
618 \\const Struct = struct {