Commit ddd98a7f10767e2bea43fb35405a9414a02ecbdf | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-03-26 12:34:16-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-03-26 12:34:16-04:00
log	ddd98a7f10767e2bea43fb35405a9414a02ecbdf
tree	51f769dadbca2a6736fb0f8ce42cfc68039bba3f
parent	f7f563ea53cf58c772003a46624b87dad9c4311d
signature	Commit is signed but in an unrecognized format.

prevent ptr cast from forcing alignment resolution unnecessarily

3 files changed, 42 insertions(+), 22 deletions(-)

src
- ir.cpp
test
- stage1
  - behavior
    async_fn.zig
    cast.zig

src/ir.cpp+24-20

 @@ -237,7 +237,8 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ZigValue *val)
 static Error ir_read_const_ptr(IrAnalyze *ira, CodeGen *codegen, AstNode *source_node,
         ZigValue *out_val, ZigValue *ptr_val);
 static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrInstGen *ptr,
-        IrInst *ptr_src, ZigType *dest_type, IrInst *dest_type_src, bool safety_check_on);
+        IrInst *ptr_src, ZigType *dest_type, IrInst *dest_type_src, bool safety_check_on,
+        bool keep_bigger_alignment);
 static ZigValue *ir_resolve_const(IrAnalyze *ira, IrInstGen *value, UndefAllowed undef_allowed);
 static Error resolve_ptr_align(IrAnalyze *ira, ZigType *ty, uint32_t *result_align);
 static IrInstGen *ir_analyze_int_to_ptr(IrAnalyze *ira, IrInst* source_instr, IrInstGen *target,
 @@ -15066,7 +15067,8 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
             dest_ptr_type = wanted_type->data.maybe.child_type;
         }
         if (dest_ptr_type != nullptr) {
-            return ir_analyze_ptr_cast(ira, source_instr, value, source_instr, wanted_type, source_instr, true);
+            return ir_analyze_ptr_cast(ira, source_instr, value, source_instr, wanted_type, source_instr, true,
+                    false);
         }
     }
 @@ -15108,7 +15110,7 @@ static IrInstGen *ir_analyze_cast(IrAnalyze *ira, IrInst *source_instr,
             actual_type->data.pointer.child_type, source_node,
             !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
     {
-        return ir_analyze_ptr_cast(ira, source_instr, value, source_instr, wanted_type, source_instr, true);
+        return ir_analyze_ptr_cast(ira, source_instr, value, source_instr, wanted_type, source_instr, true, false);
     }
     // cast from integer to C pointer
 @@ -18576,7 +18578,7 @@ static IrInstGen *ir_resolve_result_raw(IrAnalyze *ira, IrInst *suspend_source_i
             result_loc->written = true;
             result_loc->resolved_loc = ir_analyze_ptr_cast(ira, suspend_source_instr, parent_result_loc,
-                    &parent_result_loc->base, ptr_type, &result_cast->base.source_instruction->base, false);
+                    &parent_result_loc->base, ptr_type, &result_cast->base.source_instruction->base, false, false);
             return result_loc->resolved_loc;
         }
         case ResultLocIdBitCast: {
 @@ -18670,7 +18672,7 @@ static IrInstGen *ir_resolve_result_raw(IrAnalyze *ira, IrInst *suspend_source_i
             result_loc->written = true;
             result_loc->resolved_loc = ir_analyze_ptr_cast(ira, suspend_source_instr, parent_result_loc,
-                    &parent_result_loc->base, ptr_type, &result_bit_cast->base.source_instruction->base, false);
+                    &parent_result_loc->base, ptr_type, &result_bit_cast->base.source_instruction->base, false, false);
             return result_loc->resolved_loc;
         }
     }
 @@ -22947,7 +22949,7 @@ static IrInstGen *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstSrcSwi
             ref_type->data.pointer.bit_offset_in_host, ref_type->data.pointer.host_int_bytes,
             ref_type->data.pointer.allow_zero);
         return ir_analyze_ptr_cast(ira, &instruction->base.base, target_value_ptr,
-                &instruction->target_value_ptr->base, new_target_value_ptr_type, &instruction->base.base, false);
+                &instruction->target_value_ptr->base, new_target_value_ptr_type, &instruction->base.base, false, false);
     } else {
         ir_add_error(ira, &instruction->base.base,
             buf_sprintf("switch on type '%s' provides no expression parameter", buf_ptr(&target_type->name)));
 @@ -23030,7 +23032,7 @@ static IrInstGen *ir_analyze_instruction_switch_else_var(IrAnalyze *ira,
             ref_type->data.pointer.bit_offset_in_host, ref_type->data.pointer.host_int_bytes,
             ref_type->data.pointer.allow_zero);
         return ir_analyze_ptr_cast(ira, &instruction->base.base, target_value_ptr,
-                &instruction->target_value_ptr->base, new_target_value_ptr_type, &instruction->base.base, false);
+                &instruction->target_value_ptr->base, new_target_value_ptr_type, &instruction->base.base, false, false);
     }
     return target_value_ptr;
 @@ -27814,7 +27816,8 @@ static IrInstGen *ir_align_cast(IrAnalyze *ira, IrInstGen *target, uint32_t alig
 }
 static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrInstGen *ptr,
-        IrInst *ptr_src, ZigType *dest_type, IrInst *dest_type_src, bool safety_check_on)
+        IrInst *ptr_src, ZigType *dest_type, IrInst *dest_type_src, bool safety_check_on,
+        bool keep_bigger_alignment)
 {
     Error err;
 @@ -27853,14 +27856,16 @@ static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrIn
         ir_add_error(ira, source_instr, buf_sprintf("cast discards const qualifier"));
         return ira->codegen->invalid_inst_gen;
     }
-    uint32_t src_align_bytes;
-    if ((err = resolve_ptr_align(ira, src_type, &src_align_bytes)))
-        return ira->codegen->invalid_inst_gen;
     uint32_t dest_align_bytes;
     if ((err = resolve_ptr_align(ira, dest_type, &dest_align_bytes)))
         return ira->codegen->invalid_inst_gen;
+    uint32_t src_align_bytes = 0;
+    if (keep_bigger_alignment || dest_align_bytes != 1) {
+        if ((err = resolve_ptr_align(ira, src_type, &src_align_bytes)))
+            return ira->codegen->invalid_inst_gen;
+    }
     if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
         return ira->codegen->invalid_inst_gen;
 @@ -27935,16 +27940,15 @@ static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrIn
         }
         result->value->type = dest_type;
-        // Keep the bigger alignment, it can only help-
+        // Keep the bigger alignment, it can only help- unless the target is zero bits.
-        // unless the target is zero bits.
+        if (keep_bigger_alignment && src_align_bytes > dest_align_bytes && type_has_bits(ira->codegen, dest_type)) {
-        if (src_align_bytes > dest_align_bytes && type_has_bits(ira->codegen, dest_type)) {
             result = ir_align_cast(ira, result, src_align_bytes, false);
         }
         return result;
     }
-    if (dest_align_bytes > src_align_bytes) {
+    if (src_align_bytes != 0 && dest_align_bytes > src_align_bytes) {
         ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
         add_error_note(ira->codegen, msg, ptr_src->source_node,
                 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&src_type->name), src_align_bytes));
 @@ -27955,10 +27959,9 @@ static IrInstGen *ir_analyze_ptr_cast(IrAnalyze *ira, IrInst* source_instr, IrIn
     IrInstGen *casted_ptr = ir_build_ptr_cast_gen(ira, source_instr, dest_type, ptr, safety_check_on);
-    // Keep the bigger alignment, it can only help-
+    // Keep the bigger alignment, it can only help- unless the target is zero bits.
-    // unless the target is zero bits.
     IrInstGen *result;
-    if (src_align_bytes > dest_align_bytes && type_has_bits(ira->codegen, dest_type)) {
+    if (keep_bigger_alignment && src_align_bytes > dest_align_bytes && type_has_bits(ira->codegen, dest_type)) {
         result = ir_align_cast(ira, casted_ptr, src_align_bytes, false);
         if (type_is_invalid(result->value->type))
             return ira->codegen->invalid_inst_gen;
 @@ -27979,8 +27982,9 @@ static IrInstGen *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstSrcPtrCa
     if (type_is_invalid(src_type))
         return ira->codegen->invalid_inst_gen;
+    bool keep_bigger_alignment = true;
     return ir_analyze_ptr_cast(ira, &instruction->base.base, ptr, &instruction->ptr->base,
-            dest_type, &dest_type_value->base, instruction->safety_check_on);
+            dest_type, &dest_type_value->base, instruction->safety_check_on, keep_bigger_alignment);
 }
 static void buf_write_value_bytes_array(CodeGen *codegen, uint8_t *buf, ZigValue *val, size_t len) {

test/stage1/behavior/async_fn.zig+16

...	@@ -1547,3 +1547,19 @@ test "noasync on function calls" {	...	@@ -1547,3 +1547,19 @@ test "noasync on function calls" {
1547	expectEqual(@as(i32, 42), noasync S1.c().b);	1547	expectEqual(@as(i32, 42), noasync S1.c().b);
1548	expectEqual(@as(i32, 42), (try noasync S1.d()).b);	1548	expectEqual(@as(i32, 42), (try noasync S1.d()).b);
1549	}	1549	}
		1550
		1551	test "avoid forcing frame alignment resolution implicit cast to *c_void" {
		1552	const S = struct {
		1553	var x: ?*c_void = null;
		1554
		1555	fn foo() bool {
		1556	suspend {
		1557	x = @frame();
		1558	}
		1559	return true;
		1560	}
		1561	};
		1562	var frame = async S.foo();
		1563	resume @ptrCast(anyframe->bool, @alignCast(@alignOf(@Frame(S.foo)), S.x));
		1564	expect(noasync await frame);
		1565	}

test/stage1/behavior/cast.zig+2-2

...	@@ -462,10 +462,10 @@ fn foobar(func: PFN_void) void {	...	@@ -462,10 +462,10 @@ fn foobar(func: PFN_void) void {
462		462
463	test "implicit ptr to *c_void" {	463	test "implicit ptr to *c_void" {
464	var a: u32 = 1;	464	var a: u32 = 1;
465	var ptr: *c_void = &a;	465	var ptr: *align(@alignOf(u32)) c_void = &a;
466	var b: u32 = @ptrCast(u32, ptr);	466	var b: u32 = @ptrCast(u32, ptr);
467	expect(b.* == 1);	467	expect(b.* == 1);
468	var ptr2: ?*c_void = &a;	468	var ptr2: ?*align(@alignOf(u32)) c_void = &a;
469	var c: u32 = @ptrCast(u32, ptr2.?);	469	var c: u32 = @ptrCast(u32, ptr2.?);
470	expect(c.* == 1);	470	expect(c.* == 1);
471	}	471	}