From 91989e70ba68e3543acffef079d97c9416b5259c Mon Sep 17 00:00:00 2001 From: Matthew McAllister Date: Tue, 12 Feb 2019 21:22:16 -0800 Subject: Fix lvalue dereference type checking Previously, if a dereference instruction was an lvalue, it would fail to typecheck that the value being dereferenced was indeed a pointer. Although a little clunky, this change obviates the need for redundant type checks scattered about the analysis. --- src/ir.cpp | 39 ++++++++++++++++++--------------------- 1 file changed, 18 insertions(+), 21 deletions(-) (limited to 'src/ir.cpp') diff --git a/src/ir.cpp b/src/ir.cpp index 0fcbb60fe8..5e6ff16f85 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -1307,6 +1307,7 @@ static IrInstruction *ir_build_un_op(IrBuilder *irb, Scope *scope, AstNode *sour IrInstructionUnOp *br_instruction = ir_build_instruction(irb, scope, source_node); br_instruction->op_id = op_id; br_instruction->value = value; + br_instruction->lval = LValNone; ir_ref_instruction(value, irb->current_basic_block); @@ -7223,7 +7224,13 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop if (value == irb->codegen->invalid_instruction) return value; - return ir_build_un_op(irb, scope, node, IrUnOpDereference, value); + // We essentially just converted any lvalue from &(x.*) to (&x).*; + // this inhibits checking that x is a pointer later, so we directly + // record whether the pointer check is needed + IrInstructionUnOp *result = (IrInstructionUnOp*)ir_build_un_op(irb, scope, node, IrUnOpDereference, value); + result->lval = lval; + + return &result->base; } case NodeTypeUnwrapOptional: { AstNode *expr_node = node->data.unwrap_optional.expr; @@ -11437,7 +11444,7 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc return load_ptr_instruction; } else { ir_add_error_node(ira, source_instruction->source_node, - buf_sprintf("attempt to dereference non pointer type '%s'", + buf_sprintf("attempt to dereference non-pointer type '%s'", buf_ptr(&type_entry->name))); return ira->codegen->invalid_instruction; } @@ -13616,12 +13623,6 @@ no_mem_slot: static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr, IrInstruction *uncasted_value) { - if (ptr->value.type->id != ZigTypeIdPointer) { - ir_add_error(ira, ptr, - buf_sprintf("attempt to dereference non pointer type '%s'", buf_ptr(&ptr->value.type->name))); - return ira->codegen->invalid_instruction; - } - if (ptr->value.data.x_ptr.special == ConstPtrSpecialDiscard) { return ir_const_void(ira, source_instr); } @@ -14550,11 +14551,18 @@ static IrInstruction *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstruction buf_ptr(&ptr_type->name))); return ira->codegen->invalid_instruction; } - // this dereference is always an rvalue because in the IR gen we identify lvalue and emit - // one of the ptr instructions + IrInstruction *result = ir_get_deref(ira, &instruction->base, ptr); if (result == ira->codegen->invalid_instruction) return ira->codegen->invalid_instruction; + + // If the result needs to be an lvalue, type check it + if (instruction->lval == LValPtr && result->value.type->id != ZigTypeIdPointer) { + ir_add_error(ira, &instruction->base, + buf_sprintf("attempt to dereference non-pointer type '%s'", buf_ptr(&result->value.type->name))); + return ira->codegen->invalid_instruction; + } + return result; } case IrUnOpOptional: @@ -15380,12 +15388,6 @@ static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstruc if (type_is_invalid(container_ptr->value.type)) return ira->codegen->invalid_instruction; - if (container_ptr->value.type->id != ZigTypeIdPointer) { - ir_add_error_node(ira, field_ptr_instruction->base.source_node, - buf_sprintf("attempt to dereference non-pointer type '%s'", - buf_ptr(&container_ptr->value.type->name))); - return ira->codegen->invalid_instruction; - } ZigType *container_type = container_ptr->value.type->data.pointer.child_type; Buf *field_name = field_ptr_instruction->field_name_buffer; @@ -16596,11 +16598,6 @@ static IrInstruction *ir_analyze_instruction_switch_target(IrAnalyze *ira, return ir_const_type(ira, &switch_target_instruction->base, ptr_type->data.pointer.child_type); } - if (target_value_ptr->value.type->id != ZigTypeIdPointer) { - ir_add_error(ira, target_value_ptr, buf_sprintf("invalid deref on switch target")); - return ira->codegen->invalid_instruction; - } - ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type; ConstExprValue *pointee_val = nullptr; if (instr_is_comptime(target_value_ptr)) { -- cgit v1.2.3 From c8ce351ec982608d3ea0c60a34c7b18d894dee01 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 19 Feb 2019 15:34:44 -0500 Subject: pull request fixups --- src/ir.cpp | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-) (limited to 'src/ir.cpp') diff --git a/src/ir.cpp b/src/ir.cpp index e5f09dd93a..3e48779b93 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -1303,15 +1303,23 @@ static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *s return &ptr_type_of_instruction->base; } -static IrInstruction *ir_build_un_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrUnOp op_id, IrInstruction *value) { - IrInstructionUnOp *br_instruction = ir_build_instruction(irb, scope, source_node); - br_instruction->op_id = op_id; - br_instruction->value = value; - br_instruction->lval = LValNone; +static IrInstruction *ir_build_un_op_lval(IrBuilder *irb, Scope *scope, AstNode *source_node, IrUnOp op_id, + IrInstruction *value, LVal lval) +{ + IrInstructionUnOp *instruction = ir_build_instruction(irb, scope, source_node); + instruction->op_id = op_id; + instruction->value = value; + instruction->lval = lval; ir_ref_instruction(value, irb->current_basic_block); - return &br_instruction->base; + return &instruction->base; +} + +static IrInstruction *ir_build_un_op(IrBuilder *irb, Scope *scope, AstNode *source_node, IrUnOp op_id, + IrInstruction *value) +{ + return ir_build_un_op_lval(irb, scope, source_node, op_id, value, LValNone); } static IrInstruction *ir_build_container_init_list(IrBuilder *irb, Scope *scope, AstNode *source_node, @@ -7227,10 +7235,7 @@ static IrInstruction *ir_gen_node_raw(IrBuilder *irb, AstNode *node, Scope *scop // We essentially just converted any lvalue from &(x.*) to (&x).*; // this inhibits checking that x is a pointer later, so we directly // record whether the pointer check is needed - IrInstructionUnOp *result = (IrInstructionUnOp*)ir_build_un_op(irb, scope, node, IrUnOpDereference, value); - result->lval = lval; - - return &result->base; + return ir_build_un_op_lval(irb, scope, node, IrUnOpDereference, value, lval); } case NodeTypeUnwrapOptional: { AstNode *expr_node = node->data.unwrap_optional.expr; @@ -13685,6 +13690,8 @@ no_mem_slot: static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr, IrInstruction *uncasted_value) { + assert(ptr->value.type->id == ZigTypeIdPointer); + if (ptr->value.data.x_ptr.special == ConstPtrSpecialDiscard) { return ir_const_void(ira, source_instr); } -- cgit v1.2.3