Commit bd4d4ee51efebb79ed7b563a10eec992a71220fd | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-11-27 00:14:19-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-11-27 00:14:19-05:00
log	bd4d4ee51efebb79ed7b563a10eec992a71220fd
tree	4f01f7f8c967dc8e94ef94eaedfa2f46978ec04d
parent	1fba7f36960551fe0a12aa754c2d789c8784a8cc

IR: detect error for exceeding branch quota

3 files changed, 41 insertions(+), 27 deletions(-)

src/all_types.hpp+2

...	@@ -36,6 +36,8 @@ struct IrExecutable {	...	@@ -36,6 +36,8 @@ struct IrExecutable {
36	ZigList<IrBasicBlock *> basic_block_list;	36	ZigList<IrBasicBlock *> basic_block_list;
37	size_t mem_slot_count;	37	size_t mem_slot_count;
38	size_t next_debug_id;	38	size_t next_debug_id;
		39	size_t backward_branch_count;
		40	size_t backward_branch_quota;
39	bool invalid;	41	bool invalid;
40	ZigList<LabelTableEntry *> all_labels;	42	ZigList<LabelTableEntry *> all_labels;
41	ZigList<AstNode *> goto_list;	43	ZigList<AstNode *> goto_list;

src/analyze.cpp+5-1

src/ir.cpp+34-26

 @@ -2957,8 +2957,24 @@ static void ir_finish_bb(IrAnalyze *ira) {
     }
 }
-static void ir_inline_bb(IrAnalyze *ira, IrBasicBlock *old_bb) {
+static TypeTableEntry *ir_unreach_error(IrAnalyze *ira) {
+    ira->block_queue_index = SIZE_MAX;
+    ira->new_irb.exec->invalid = true;
+    return ira->codegen->builtin_types.entry_unreachable;
+}
+static TypeTableEntry *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction, IrBasicBlock *old_bb) {
+    if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
+        ira->new_irb.exec->backward_branch_count += 1;
+        if (ira->new_irb.exec->backward_branch_count > ira->new_irb.exec->backward_branch_quota) {
+            add_node_error(ira->codegen, source_instruction->source_node,
+                    buf_sprintf("evaluation exceeded %zu backwards branches", ira->new_irb.exec->backward_branch_quota));
+            return ir_unreach_error(ira);
+        }
+    }
     ir_start_bb(ira, old_bb, ira->old_irb.current_basic_block);
+    return ira->codegen->builtin_types.entry_unreachable;
 }
 static TypeTableEntry *ir_finish_anal(IrAnalyze *ira, TypeTableEntry *result_type) {
 @@ -3439,12 +3455,12 @@ static TypeTableEntry *ir_analyze_instruction_return(IrAnalyze *ira,
 {
     IrInstruction *value = return_instruction->value->other;
     if (value->type_entry->id == TypeTableEntryIdInvalid)
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        return ir_unreach_error(ira);
     ira->implicit_return_type_list.append(value);
     IrInstruction *casted_value = ir_get_casted_value(ira, value, ira->explicit_return_type);
     if (casted_value == ira->codegen->invalid_instruction)
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        return ir_unreach_error(ira);
     ir_build_return_from(&ira->new_irb, &return_instruction->base, casted_value);
     return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
 @@ -4302,11 +4318,8 @@ static TypeTableEntry *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructio
 static TypeTableEntry *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_instruction) {
     IrBasicBlock *old_dest_block = br_instruction->dest_block;
-    // TODO detect backward jumps
     if (br_instruction->is_inline || old_dest_block->ref_count == 1) {
-        ir_inline_bb(ira, old_dest_block);
+        return ir_inline_bb(ira, &br_instruction->base, old_dest_block);
-        return ira->codegen->builtin_types.entry_unreachable;
     }
     IrBasicBlock *new_bb = ir_get_new_bb(ira, old_dest_block);
 @@ -4317,28 +4330,24 @@ static TypeTableEntry *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr
 static TypeTableEntry *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCondBr *cond_br_instruction) {
     IrInstruction *condition = cond_br_instruction->condition->other;
     if (condition->type_entry->id == TypeTableEntryIdInvalid)
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        return ir_unreach_error(ira);
-    // TODO detect backward jumps
     if (cond_br_instruction->is_inline || condition->static_value.special != ConstValSpecialRuntime) {
         bool cond_is_true;
         if (!ir_resolve_bool(ira, condition, &cond_is_true))
-            return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+            return ir_unreach_error(ira);
         IrBasicBlock *old_dest_block = cond_is_true ?
             cond_br_instruction->then_block : cond_br_instruction->else_block;
-        if (cond_br_instruction->is_inline || old_dest_block->ref_count == 1) {
+        if (cond_br_instruction->is_inline || old_dest_block->ref_count == 1)
-            ir_inline_bb(ira, old_dest_block);
+            return ir_inline_bb(ira, &cond_br_instruction->base, old_dest_block);
-            return ira->codegen->builtin_types.entry_unreachable;
-        }
     }
     TypeTableEntry *bool_type = ira->codegen->builtin_types.entry_bool;
     IrInstruction *casted_condition = ir_get_casted_value(ira, condition, bool_type);
     if (casted_condition == ira->codegen->invalid_instruction)
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        return ir_unreach_error(ira);
     IrBasicBlock *new_then_block = ir_get_new_bb(ira, cond_br_instruction->then_block);
     IrBasicBlock *new_else_block = ir_get_new_bb(ira, cond_br_instruction->else_block);
 @@ -5418,9 +5427,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_br(IrAnalyze *ira,
 {
     IrInstruction *target_value = switch_br_instruction->target_value->other;
     if (target_value->type_entry->id == TypeTableEntryIdInvalid)
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        return ir_unreach_error(ira);
-    // TODO detect backward jumps
     size_t case_count = switch_br_instruction->case_count;
     bool is_inline = switch_br_instruction->is_inline;
 @@ -5428,27 +5435,26 @@ static TypeTableEntry *ir_analyze_instruction_switch_br(IrAnalyze *ira,
     if (is_inline || target_value->static_value.special != ConstValSpecialRuntime) {
         ConstExprValue *target_val = ir_resolve_const(ira, target_value);
         if (!target_val)
-            return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+            return ir_unreach_error(ira);
         for (size_t i = 0; i < case_count; i += 1) {
             IrInstructionSwitchBrCase *old_case = &switch_br_instruction->cases[i];
             IrInstruction *case_value = old_case->value->other;
             if (case_value->type_entry->id == TypeTableEntryIdInvalid)
-                return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+                return ir_unreach_error(ira);
             IrInstruction *casted_case_value = ir_get_casted_value(ira, case_value, target_value->type_entry);
             if (casted_case_value->type_entry->id == TypeTableEntryIdInvalid)
-                return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+                return ir_unreach_error(ira);
             ConstExprValue *case_val = ir_resolve_const(ira, casted_case_value);
             if (!case_val)
-                return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+                return ir_unreach_error(ira);
             if (const_values_equal(target_val, case_val, target_value->type_entry)) {
                 IrBasicBlock *old_dest_block = old_case->block;
                 if (is_inline || old_dest_block->ref_count == 1) {
-                    ir_inline_bb(ira, old_dest_block);
+                    return ir_inline_bb(ira, &switch_br_instruction->base, old_dest_block);
-                    return ira->codegen->builtin_types.entry_unreachable;
                 } else {
                     IrBasicBlock *new_dest_block = ir_get_new_bb(ira, old_dest_block);
                     ir_build_br_from(&ira->new_irb, &switch_br_instruction->base, new_dest_block);
 @@ -5840,7 +5846,9 @@ TypeTableEntry *ir_analyze(CodeGen *codegen, IrExecutable *old_exec, IrExecutabl
         ira->instruction_index += 1;
     }
-    if (ira->implicit_return_type_list.length == 0) {
+    if (new_exec->invalid) {
+        return ira->codegen->builtin_types.entry_invalid;
+    } else if (ira->implicit_return_type_list.length == 0) {
         return codegen->builtin_types.entry_unreachable;
     } else {
         return ir_resolve_peer_types(ira, expected_type_source_node, ira->implicit_return_type_list.items,

...	@@ -17,6 +17,8 @@	...	@@ -17,6 +17,8 @@
17	#include "parser.hpp"	17	#include "parser.hpp"
18	#include "zig_llvm.hpp"	18	#include "zig_llvm.hpp"
19		19
		20	static const size_t default_backward_branch_quota = 1000;
		21
20	static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEntry *enum_type);	22	static void resolve_enum_type(CodeGen g, ImportTableEntry import, TypeTableEntry *enum_type);
21	static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableEntry *struct_type);	23	static void resolve_struct_type(CodeGen g, ImportTableEntry import, TypeTableEntry *struct_type);
22		24
...	@@ -836,7 +838,6 @@ static IrInstruction analyze_const_value(CodeGen g, BlockContext *scope, AstNo	...	@@ -836,7 +838,6 @@ static IrInstruction analyze_const_value(CodeGen g, BlockContext *scope, AstNo
836	TypeTableEntry *expected_type)	838	TypeTableEntry *expected_type)
837	{	839	{
838	IrExecutable ir_executable = {0};	840	IrExecutable ir_executable = {0};
839	IrExecutable analyzed_executable = {0};
840	ir_gen(g, node, scope, &ir_executable);	841	ir_gen(g, node, scope, &ir_executable);
841		842
842	if (ir_executable.invalid)	843	if (ir_executable.invalid)
...	@@ -849,6 +850,8 @@ static IrInstruction analyze_const_value(CodeGen g, BlockContext *scope, AstNo	...	@@ -849,6 +850,8 @@ static IrInstruction analyze_const_value(CodeGen g, BlockContext *scope, AstNo
849	ir_print(stderr, &ir_executable, 4);	850	ir_print(stderr, &ir_executable, 4);
850	fprintf(stderr, "}\n");	851	fprintf(stderr, "}\n");
851	}	852	}
		853	IrExecutable analyzed_executable = {0};
		854	analyzed_executable.backward_branch_quota = default_backward_branch_quota;
852	TypeTableEntry *result_type = ir_analyze(g, &ir_executable, &analyzed_executable, expected_type, node);	855	TypeTableEntry *result_type = ir_analyze(g, &ir_executable, &analyzed_executable, expected_type, node);
853	if (result_type->id == TypeTableEntryIdInvalid)	856	if (result_type->id == TypeTableEntryIdInvalid)
854	return g->invalid_instruction;	857	return g->invalid_instruction;
...	@@ -1514,6 +1517,7 @@ static void preview_fn_proto_instance(CodeGen g, ImportTableEntry import, AstN	...	@@ -1514,6 +1517,7 @@ static void preview_fn_proto_instance(CodeGen g, ImportTableEntry import, AstN
1514	}	1517	}
1515		1518
1516	FnTableEntry *fn_table_entry = allocate<FnTableEntry>(1);	1519	FnTableEntry *fn_table_entry = allocate<FnTableEntry>(1);
		1520	fn_table_entry->analyzed_executable.backward_branch_quota = default_backward_branch_quota;
1517	fn_table_entry->import_entry = import;	1521	fn_table_entry->import_entry = import;
1518	fn_table_entry->proto_node = proto_node;	1522	fn_table_entry->proto_node = proto_node;
1519	fn_table_entry->fn_def_node = fn_def_node;	1523	fn_table_entry->fn_def_node = fn_def_node;