Commit bf7cde62c52b370f953db2cd6167a156771d8343 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-11-18 20:57:27-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-11-18 20:57:27-05:00
log	bf7cde62c52b370f953db2cd6167a156771d8343
tree	4f11799818dc793db8431332537b010620aad55f
parent	ed31ae8867fd2d7b5274c6b127d42360b48fc49c

IR: support setDebugSafety builtin function

6 files changed, 167 insertions(+), 76 deletions(-)

src
test
- self_hosted2.zig

src/all_types.hpp+8

 @@ -1449,6 +1449,7 @@ enum IrInstructionId {
     IrInstructionIdToPtrType,
     IrInstructionIdPtrTypeChild,
     IrInstructionIdSetFnTest,
+    IrInstructionIdSetDebugSafety,
     IrInstructionIdArrayType,
     IrInstructionIdSliceType,
     IrInstructionIdAsm,
 @@ -1705,6 +1706,13 @@ struct IrInstructionSetFnTest {
     IrInstruction *is_test;
 };
+struct IrInstructionSetDebugSafety {
+    IrInstruction base;
+    IrInstruction *scope_value;
+    IrInstruction *debug_safety_on;
+};
 struct IrInstructionArrayType {
     IrInstruction base;

src/ast_render.cpp+11-2

 @@ -669,6 +669,17 @@ static void render_node(AstRender *ar, AstNode *node) {
                 render_node(ar, node->data.while_expr.body);
                 break;
             }
+        case NodeTypeThisLiteral:
+            {
+                fprintf(ar->f, "this");
+                break;
+            }
+        case NodeTypeBoolLiteral:
+            {
+                const char *bool_str = node->data.bool_literal.value ? "true" : "false";
+                fprintf(ar->f, "%s", bool_str);
+                break;
+            }
         case NodeTypeFnDecl:
         case NodeTypeParamDecl:
         case NodeTypeErrorValueDecl:
 @@ -677,10 +688,8 @@ static void render_node(AstRender *ar, AstNode *node) {
         case NodeTypeStructField:
         case NodeTypeStructValueField:
         case NodeTypeUse:
-        case NodeTypeBoolLiteral:
         case NodeTypeNullLiteral:
         case NodeTypeZeroesLiteral:
-        case NodeTypeThisLiteral:
         case NodeTypeIfBoolExpr:
         case NodeTypeIfVarExpr:
         case NodeTypeForExpr:

src/codegen.cpp+1

...	@@ -1681,6 +1681,7 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,	...	@@ -1681,6 +1681,7 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
1681	case IrInstructionIdPtrTypeChild:	1681	case IrInstructionIdPtrTypeChild:
1682	case IrInstructionIdFieldPtr:	1682	case IrInstructionIdFieldPtr:
1683	case IrInstructionIdSetFnTest:	1683	case IrInstructionIdSetFnTest:
		1684	case IrInstructionIdSetDebugSafety:
1684	case IrInstructionIdArrayType:	1685	case IrInstructionIdArrayType:
1685	case IrInstructionIdSliceType:	1686	case IrInstructionIdSliceType:
1686	zig_unreachable();	1687	zig_unreachable();

src/ir.cpp+101-67

 @@ -201,6 +201,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionSetFnTest *) {
     return IrInstructionIdSetFnTest;
 }
+static constexpr IrInstructionId ir_instruction_id(IrInstructionSetDebugSafety *) {
+    return IrInstructionIdSetDebugSafety;
+}
 static constexpr IrInstructionId ir_instruction_id(IrInstructionArrayType *) {
     return IrInstructionIdArrayType;
 }
 @@ -786,6 +790,19 @@ static IrInstruction *ir_build_set_fn_test(IrBuilder *irb, AstNode *source_node,
     return &instruction->base;
 }
+static IrInstruction *ir_build_set_debug_safety(IrBuilder *irb, AstNode *source_node,
+        IrInstruction *scope_value, IrInstruction *debug_safety_on)
+{
+    IrInstructionSetDebugSafety *instruction = ir_build_instruction<IrInstructionSetDebugSafety>(irb, source_node);
+    instruction->scope_value = scope_value;
+    instruction->debug_safety_on = debug_safety_on;
+    ir_ref_instruction(scope_value);
+    ir_ref_instruction(debug_safety_on);
+    return &instruction->base;
+}
 static IrInstruction *ir_build_array_type(IrBuilder *irb, AstNode *source_node, IrInstruction *size,
         IrInstruction *child_type)
 {
 @@ -1291,6 +1308,20 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, AstNode *node) {
                 return ir_build_set_fn_test(irb, node, arg0_value, arg1_value);
             }
+        case BuiltinFnIdSetDebugSafety:
+            {
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->block_context);
+                if (arg0_value == irb->codegen->invalid_instruction)
+                    return arg0_value;
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, node->block_context);
+                if (arg1_value == irb->codegen->invalid_instruction)
+                    return arg1_value;
+                return ir_build_set_debug_safety(irb, node, arg0_value, arg1_value);
+            }
         case BuiltinFnIdMemcpy:
         case BuiltinFnIdMemset:
         case BuiltinFnIdSizeof:
 @@ -1325,7 +1356,6 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, AstNode *node) {
         case BuiltinFnIdSetFnVisible:
         case BuiltinFnIdSetFnStaticEval:
         case BuiltinFnIdSetFnNoInline:
-        case BuiltinFnIdSetDebugSafety:
             zig_panic("TODO IR gen more builtin functions");
     }
     zig_unreachable();
 @@ -2260,6 +2290,15 @@ static TypeTableEntry *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value
     return const_val->data.x_type;
 }
+static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value) {
+    if (value->static_value.special != ConstValSpecialStatic) {
+        add_node_error(ira->codegen, value->source_node,
+                buf_sprintf("unable to evaluate constant expression"));
+        return nullptr;
+    }
+    return &value->static_value;
+}
 static bool ir_resolve_bool(IrAnalyze *ira, IrInstruction *bool_value, bool *out) {
     if (bool_value == ira->codegen->invalid_instruction)
         return false;
 @@ -2273,12 +2312,9 @@ static bool ir_resolve_bool(IrAnalyze *ira, IrInstruction *bool_value, bool *out
         return false;
     }
-    ConstExprValue *const_val = &bool_value->static_value;
+    ConstExprValue *const_val = ir_resolve_const(ira, bool_value);
-    if (const_val->special == ConstValSpecialRuntime) {
+    if (!const_val)
-        add_node_error(ira->codegen, bool_value->source_node,
-                buf_sprintf("unable to evaluate constant expression"));
         return false;
-    }
     *out = const_val->data.x_bool;
     return true;
 @@ -4027,12 +4063,67 @@ static TypeTableEntry *ir_analyze_instruction_set_fn_test(IrAnalyze *ira,
     }
     fn_entry->fn_test_set_node = source_node;
-    ira->codegen->test_fn_count += 1;
+    if (fn_entry->is_test)
+        ira->codegen->test_fn_count += 1;
     ir_build_const_from(ira, &set_fn_test_instruction->base, false);
     return ira->codegen->builtin_types.entry_void;
 }
+static TypeTableEntry *ir_analyze_instruction_set_debug_safety(IrAnalyze *ira,
+        IrInstructionSetDebugSafety *set_debug_safety_instruction)
+{
+    IrInstruction *target_instruction = set_debug_safety_instruction->scope_value->other;
+    TypeTableEntry *target_type = target_instruction->type_entry;
+    if (target_type->id == TypeTableEntryIdInvalid)
+        return ira->codegen->builtin_types.entry_invalid;
+    ConstExprValue *target_val = ir_resolve_const(ira, target_instruction);
+    if (!target_val)
+        return ira->codegen->builtin_types.entry_invalid;
+    BlockContext *target_context;
+    if (target_type->id == TypeTableEntryIdBlock) {
+        target_context = target_val->data.x_block;
+    } else if (target_type->id == TypeTableEntryIdFn) {
+        target_context = target_val->data.x_fn->fn_def_node->data.fn_def.block_context;
+    } else if (target_type->id == TypeTableEntryIdMetaType) {
+        TypeTableEntry *type_arg = target_val->data.x_type;
+        if (type_arg->id == TypeTableEntryIdStruct) {
+            target_context = type_arg->data.structure.block_context;
+        } else if (type_arg->id == TypeTableEntryIdEnum) {
+            target_context = type_arg->data.enumeration.block_context;
+        } else if (type_arg->id == TypeTableEntryIdUnion) {
+            target_context = type_arg->data.unionation.block_context;
+        } else {
+            add_node_error(ira->codegen, target_instruction->source_node,
+                buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&type_arg->name)));
+            return ira->codegen->builtin_types.entry_invalid;
+        }
+    } else {
+        add_node_error(ira->codegen, target_instruction->source_node,
+            buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&target_type->name)));
+        return ira->codegen->builtin_types.entry_invalid;
+    }
+    IrInstruction *debug_safety_on_value = set_debug_safety_instruction->debug_safety_on->other;
+    bool want_debug_safety;
+    if (!ir_resolve_bool(ira, debug_safety_on_value, &want_debug_safety))
+        return ira->codegen->builtin_types.entry_invalid;
+    AstNode *source_node = set_debug_safety_instruction->base.source_node;
+    if (target_context->safety_set_node) {
+        ErrorMsg *msg = add_node_error(ira->codegen, source_node,
+                buf_sprintf("function test attribute set twice"));
+        add_error_note(ira->codegen, msg, target_context->safety_set_node, buf_sprintf("first set here"));
+        return ira->codegen->builtin_types.entry_invalid;
+    }
+    target_context->safety_set_node = source_node;
+    target_context->safety_off = !want_debug_safety;
+    ir_build_const_from(ira, &set_debug_safety_instruction->base, false);
+    return ira->codegen->builtin_types.entry_void;
+}
 static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         IrInstructionSliceType *slice_type_instruction)
 {
 @@ -4164,6 +4255,8 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
             return ir_analyze_instruction_ptr_type_child(ira, (IrInstructionPtrTypeChild *)instruction);
         case IrInstructionIdSetFnTest:
             return ir_analyze_instruction_set_fn_test(ira, (IrInstructionSetFnTest *)instruction);
+        case IrInstructionIdSetDebugSafety:
+            return ir_analyze_instruction_set_debug_safety(ira, (IrInstructionSetDebugSafety *)instruction);
         case IrInstructionIdSliceType:
             return ir_analyze_instruction_slice_type(ira, (IrInstructionSliceType *)instruction);
         case IrInstructionIdAsm:
 @@ -4257,6 +4350,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdReturn:
         case IrInstructionIdUnreachable:
         case IrInstructionIdSetFnTest:
+        case IrInstructionIdSetDebugSafety:
             return true;
         case IrInstructionIdPhi:
         case IrInstructionIdUnOp:
 @@ -4854,64 +4948,6 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
 //    return g->builtin_types.entry_void;
 //}
 //
-//static TypeTableEntry *analyze_set_debug_safety(CodeGen *g, ImportTableEntry *import,
-//        BlockContext *parent_context, AstNode *node)
-//{
-//    AstNode **target_node = &node->data.fn_call_expr.params.at(0);
-//    AstNode **value_node = &node->data.fn_call_expr.params.at(1);
-//
-//    TypeTableEntry *target_type = analyze_expression(g, import, parent_context, nullptr, *target_node);
-//    BlockContext *target_context;
-//    ConstExprValue *const_val = &get_resolved_expr(*target_node)->const_val;
-//    if (target_type->id == TypeTableEntryIdInvalid) {
-//        return g->builtin_types.entry_invalid;
-//    }
-//    if (!const_val->ok) {
-//        add_node_error(g, *target_node, buf_sprintf("unable to evaluate constant expression"));
-//        return g->builtin_types.entry_invalid;
-//    }
-//    if (target_type->id == TypeTableEntryIdBlock) {
-//        target_context = const_val->data.x_block;
-//    } else if (target_type->id == TypeTableEntryIdFn) {
-//        target_context = const_val->data.x_fn->fn_def_node->data.fn_def.block_context;
-//    } else if (target_type->id == TypeTableEntryIdMetaType) {
-//        TypeTableEntry *type_arg = const_val->data.x_type;
-//        if (type_arg->id == TypeTableEntryIdStruct) {
-//            target_context = type_arg->data.structure.block_context;
-//        } else if (type_arg->id == TypeTableEntryIdEnum) {
-//            target_context = type_arg->data.enumeration.block_context;
-//        } else if (type_arg->id == TypeTableEntryIdUnion) {
-//            target_context = type_arg->data.unionation.block_context;
-//        } else {
-//            add_node_error(g, *target_node,
-//                buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&type_arg->name)));
-//            return g->builtin_types.entry_invalid;
-//        }
-//    } else {
-//        add_node_error(g, *target_node,
-//            buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&target_type->name)));
-//        return g->builtin_types.entry_invalid;
-//    }
-//
-//    bool want_debug_safety;
-//    bool ok = resolve_const_expr_bool(g, import, parent_context, value_node, &want_debug_safety);
-//    if (!ok) {
-//        return g->builtin_types.entry_invalid;
-//    }
-//
-//    if (target_context->safety_set_node) {
-//        ErrorMsg *msg = add_node_error(g, node, buf_sprintf("debug safety for scope set twice"));
-//        add_error_note(g, msg, target_context->safety_set_node, buf_sprintf("first set here"));
-//        return g->builtin_types.entry_invalid;
-//    }
-//    target_context->safety_set_node = node;
-//
-//    target_context->safety_off = !want_debug_safety;
-//
-//    return g->builtin_types.entry_void;
-//}
 //static TypeTableEntry *analyze_builtin_fn_call_expr(CodeGen *g, ImportTableEntry *import, BlockContext *context,
 //        TypeTableEntry *expected_type, AstNode *node)
 //{
 @@ -5215,8 +5251,6 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
 //            return analyze_set_fn_static_eval(g, import, context, node);
 //        case BuiltinFnIdSetFnVisible:
 //            return analyze_set_fn_visible(g, import, context, node);
-//        case BuiltinFnIdSetDebugSafety:
-//            return analyze_set_debug_safety(g, import, context, node);
 //    }
 //    zig_unreachable();
 //}

src/ir_print.cpp+11

...	@@ -409,6 +409,14 @@ static void ir_print_set_fn_test(IrPrint irp, IrInstructionSetFnTest instructi	...	@@ -409,6 +409,14 @@ static void ir_print_set_fn_test(IrPrint irp, IrInstructionSetFnTest instructi
409	fprintf(irp->f, ")");	409	fprintf(irp->f, ")");
410	}	410	}
411		411
		412	static void ir_print_set_debug_safety(IrPrint irp, IrInstructionSetDebugSafety instruction) {
		413	fprintf(irp->f, "@setDebugSafety(");
		414	ir_print_other_instruction(irp, instruction->scope_value);
		415	fprintf(irp->f, ", ");
		416	ir_print_other_instruction(irp, instruction->debug_safety_on);
		417	fprintf(irp->f, ")");
		418	}
		419
412	static void ir_print_array_type(IrPrint irp, IrInstructionArrayType instruction) {	420	static void ir_print_array_type(IrPrint irp, IrInstructionArrayType instruction) {
413	fprintf(irp->f, "[");	421	fprintf(irp->f, "[");
414	ir_print_other_instruction(irp, instruction->size);	422	ir_print_other_instruction(irp, instruction->size);
...	@@ -541,6 +549,9 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {	...	@@ -541,6 +549,9 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
541	case IrInstructionIdSetFnTest:	549	case IrInstructionIdSetFnTest:
542	ir_print_set_fn_test(irp, (IrInstructionSetFnTest *)instruction);	550	ir_print_set_fn_test(irp, (IrInstructionSetFnTest *)instruction);
543	break;	551	break;
		552	case IrInstructionIdSetDebugSafety:
		553	ir_print_set_debug_safety(irp, (IrInstructionSetDebugSafety *)instruction);
		554	break;
544	case IrInstructionIdArrayType:	555	case IrInstructionIdArrayType:
545	ir_print_array_type(irp, (IrInstructionArrayType *)instruction);	556	ir_print_array_type(irp, (IrInstructionArrayType *)instruction);
546	break;	557	break;

test/self_hosted2.zig+35-7

...	@@ -1,13 +1,41 @@	...	@@ -1,13 +1,41 @@
1	fn add(a: i32, b: i32) -> i32 {	1	pub const SYS_write = 1;
2	a + b	2	pub const SYS_exit = 60;
		3	pub const stdout_fileno = 1;
		4	const text = "hello\n";
		5
		6	export nakedcc fn _start() -> unreachable {
		7	myMain();
		8	}
		9
		10	fn myMain() -> unreachable {
		11	write(stdout_fileno, &text[0], text.len);
		12	exit(0);
3	}	13	}
4		14
5	fn assert(ok: bool) {	15	pub inline fn syscall1(number: usize, arg1: usize) -> usize {
6	if (!ok) @unreachable();	16	asm volatile ("syscall"
		17	: [ret] "={rax}" (-> usize)
		18	: [number] "{rax}" (number),
		19	[arg1] "{rdi}" (arg1)
		20	: "rcx", "r11")
7	}	21	}
8		22
9	fn testAdd() {	23	pub inline fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) -> usize {
10	@setFnTest(this, true);	24	asm volatile ("syscall"
		25	: [ret] "={rax}" (-> usize)
		26	: [number] "{rax}" (number),
		27	[arg1] "{rdi}" (arg1),
		28	[arg2] "{rsi}" (arg2),
		29	[arg3] "{rdx}" (arg3)
		30	: "rcx", "r11")
		31	}
11		32
12	assert(add(2, 3) == 5);	33	pub fn write(fd: i32, buf: &const u8, count: usize) -> usize {
		34	syscall3(SYS_write, usize(fd), usize(buf), count)
13	}	35	}
		36
		37	pub fn exit(status: i32) -> unreachable {
		38	syscall1(SYS_exit, usize(status));
		39	@unreachable()
		40	}
		41