| author |  Veikka Tuominen <git@vexu.eu> 2022-08-05 17:36:45+03:00 |
| committer | Veikka Tuominen <git@vexu.eu> 2022-08-05 22:13:58+03:00 |
| log | 9116e26c1ffb49cf68bebf3af2a019af08474d12 |
| tree | d978f21d18c6c1f00e6ad94f7219b836b8651eb4 |
| parent | 5605f6e0e302cbf345a5229ea58aef6757fe139d |
Sema: add null check for implicit casts
5 files changed, 46 insertions(+), 28 deletions(-)
src
src/Sema.zig+18-4
| ... | ... | @@ -1577,8 +1577,7 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) |
| 1577 | 1577 | |
| 1578 | 1578 | // st.index = 0; |
| 1579 | 1579 | const index_field_ptr = try sema.fieldPtr(&err_trace_block, src, st_ptr, "index", src, true); |
| 1580 | const zero = try sema.addConstant(Type.usize, Value.zero); | |
| 1581 | try sema.storePtr2(&err_trace_block, src, index_field_ptr, src, zero, src, .store); | |
| 1580 | try sema.storePtr2(&err_trace_block, src, index_field_ptr, src, .zero_usize, src, .store); | |
| 1582 | 1581 | |
| 1583 | 1582 | // @errorReturnTrace() = &st; |
| 1584 | 1583 | _ = try err_trace_block.addUnOp(.set_err_return_trace, st_ptr); |
| ... | ... | @@ -17134,7 +17133,7 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A |
| 17134 | 17133 | const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize); |
| 17135 | 17134 | const ok = if (ptr_ty.isSlice()) ok: { |
| 17136 | 17135 | const len = try sema.analyzeSliceLen(block, ptr_src, ptr); |
| 17137 | const len_zero = try block.addBinOp(.cmp_eq, len, try sema.addConstant(Type.usize, Value.zero)); | |
| 17136 | const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize); | |
| 17138 | 17137 | break :ok try block.addBinOp(.bit_or, len_zero, is_aligned); |
| 17139 | 17138 | } else is_aligned; |
| 17140 | 17139 | try sema.addSafetyCheck(block, ok, .incorrect_alignment); |
| ... | ... | @@ -21957,7 +21956,6 @@ fn coerceExtra( |
| 21957 | 21956 | .ok => {}, |
| 21958 | 21957 | else => break :src_c_ptr, |
| 21959 | 21958 | } |
| 21960 | // TODO add safety check for null pointer | |
| 21961 | 21959 | return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src); |
| 21962 | 21960 | } |
| 21963 | 21961 | |
| ... | ... | @@ -24430,6 +24428,22 @@ fn coerceCompatiblePtrs( |
| 24430 | 24428 | return sema.addConstant(dest_ty, val); |
| 24431 | 24429 | } |
| 24432 | 24430 | try sema.requireRuntimeBlock(block, inst_src, null); |
| 24431 | const inst_ty = sema.typeOf(inst); | |
| 24432 | const inst_allows_zero = (inst_ty.zigTypeTag() == .Pointer and inst_ty.ptrAllowsZero()) or true; | |
| 24433 | if (block.wantSafety() and inst_allows_zero and !dest_ty.ptrAllowsZero()) { | |
| 24434 | const actual_ptr = if (inst_ty.isSlice()) | |
| 24435 | try sema.analyzeSlicePtr(block, inst_src, inst, inst_ty) | |
| 24436 | else | |
| 24437 | inst; | |
| 24438 | const ptr_int = try block.addUnOp(.ptrtoint, actual_ptr); | |
| 24439 | const is_non_zero = try block.addBinOp(.cmp_neq, ptr_int, .zero_usize); | |
| 24440 | const ok = if (inst_ty.isSlice()) ok: { | |
| 24441 | const len = try sema.analyzeSliceLen(block, inst_src, inst); | |
| 24442 | const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize); | |
| 24443 | break :ok try block.addBinOp(.bit_or, len_zero, is_non_zero); | |
| 24444 | } else is_non_zero; | |
| 24445 | try sema.addSafetyCheck(block, ok, .cast_to_null); | |
| 24446 | } | |
| 24433 | 24447 | return sema.bitCast(block, dest_ty, inst, inst_src); |
| 24434 | 24448 | } |
| 24435 | 24449 |
test/cases/safety/pointer casting null to non-optional pointer.zig +7-3
| ... | ... | @@ -1,16 +1,20 @@ |
| 1 | 1 | const std = @import("std"); |
| 2 | 2 | |
| 3 | 3 | pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { |
| 4 | _ = message; | |
| 5 | 4 | _ = stack_trace; |
| 6 | std.process.exit(0); | |
| 5 | if (std.mem.eql(u8, message, "cast causes pointer to be null")) { | |
| 6 | std.process.exit(0); | |
| 7 | } | |
| 8 | std.process.exit(1); | |
| 7 | 9 | } |
| 10 | ||
| 8 | 11 | pub fn main() !void { |
| 9 | 12 | var c_ptr: [*c]u8 = 0; |
| 10 | 13 | var zig_ptr: *u8 = c_ptr; |
| 11 | 14 | _ = zig_ptr; |
| 12 | 15 | return error.TestFailed; |
| 13 | 16 | } |
| 17 | ||
| 14 | 18 | // run |
| 15 | // backend=stage1 | |
| 19 | // backend=llvm | |
| 16 | 20 | // target=native |
test/cases/safety/slicing null C pointer - runtime len.zig created+20
| ... | ... | @@ -0,0 +1,20 @@ |
| 1 | const std = @import("std"); | |
| 2 | ||
| 3 | pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { | |
| 4 | _ = stack_trace; | |
| 5 | if (std.mem.eql(u8, message, "attempt to use null value")) { | |
| 6 | std.process.exit(0); | |
| 7 | } | |
| 8 | std.process.exit(1); | |
| 9 | } | |
| 10 | ||
| 11 | pub fn main() !void { | |
| 12 | var ptr: [*c]const u32 = null; | |
| 13 | var len: usize = 3; | |
| 14 | var slice = ptr[0..len]; | |
| 15 | _ = slice; | |
| 16 | return error.TestFailed; | |
| 17 | } | |
| 18 | // run | |
| 19 | // backend=llvm | |
| 20 | // target=native |
test/cases/safety/slicing null C pointer runtime len.zig deleted-20
| ... | ... | @@ -1,20 +0,0 @@ |
| 1 | const std = @import("std"); | |
| 2 | ||
| 3 | pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace) noreturn { | |
| 4 | _ = stack_trace; | |
| 5 | if (std.mem.eql(u8, message, "attempt to use null value")) { | |
| 6 | std.process.exit(0); | |
| 7 | } | |
| 8 | std.process.exit(1); | |
| 9 | } | |
| 10 | ||
| 11 | pub fn main() !void { | |
| 12 | var ptr: [*c]const u32 = null; | |
| 13 | var len: usize = 3; | |
| 14 | var slice = ptr[0..len]; | |
| 15 | _ = slice; | |
| 16 | return error.TestFailed; | |
| 17 | } | |
| 18 | // run | |
| 19 | // backend=llvm | |
| 20 | // target=native | |
| \ No newline at end of file |
test/cases/safety/slicing null C pointer.zig +1-1
| ... | ... | @@ -16,4 +16,4 @@ pub fn main() !void { |
| 16 | 16 | } |
| 17 | 17 | // run |
| 18 | 18 | // backend=llvm |
| 19 | // target=native | |
| \ No newline at end of file | ||
| 19 | // target=native |