Commit 6bbee194b9
Changed files (5)
src/all_types.hpp
@@ -1488,9 +1488,11 @@ struct IrInstruction {
ConstExprValue value;
size_t debug_id;
LLVMValueRef llvm_value;
- // if ref_count is zero, instruction can be omitted in codegen
+ // if ref_count is zero and the instruction has no side effects,
+ // the instruction can be omitted in codegen
size_t ref_count;
IrInstruction *other;
+ IrBasicBlock *owner_bb;
};
struct IrInstructionCondBr {
src/codegen.cpp
@@ -2393,7 +2393,7 @@ static void ir_render(CodeGen *g, FnTableEntry *fn_entry) {
assert(executable->basic_block_list.length > 0);
for (size_t block_i = 0; block_i < executable->basic_block_list.length; block_i += 1) {
IrBasicBlock *current_block = executable->basic_block_list.at(block_i);
- assert(current_block->ref_count > 0);
+ //assert(current_block->ref_count > 0);
assert(current_block->llvm_block);
LLVMPositionBuilderAtEnd(g->builder, current_block->llvm_block);
for (size_t instr_i = 0; instr_i < current_block->instruction_list.length; instr_i += 1) {
src/ir.cpp
@@ -473,19 +473,20 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToEnum *) {
}
template<typename T>
-static T *ir_create_instruction(IrExecutable *exec, Scope *scope, AstNode *source_node) {
+static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
T *special_instruction = allocate<T>(1);
special_instruction->base.id = ir_instruction_id(special_instruction);
special_instruction->base.scope = scope;
special_instruction->base.source_node = source_node;
- special_instruction->base.debug_id = exec_next_debug_id(exec);
+ special_instruction->base.debug_id = exec_next_debug_id(irb->exec);
+ special_instruction->base.owner_bb = irb->current_basic_block;
return special_instruction;
}
template<typename T>
static T *ir_build_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
assert(source_node);
- T *special_instruction = ir_create_instruction<T>(irb->exec, scope, source_node);
+ T *special_instruction = ir_create_instruction<T>(irb, scope, source_node);
ir_instruction_append(irb->current_basic_block, &special_instruction->base);
return special_instruction;
}
@@ -554,7 +555,7 @@ static IrInstruction *ir_create_const(IrBuilder *irb, Scope *scope, AstNode *sou
TypeTableEntry *type_entry, bool depends_on_compile_var)
{
assert(type_entry);
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, scope, source_node);
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
const_instruction->base.value.type = type_entry;
const_instruction->base.value.special = ConstValSpecialStatic;
const_instruction->base.value.depends_on_compile_var = depends_on_compile_var;
@@ -610,7 +611,7 @@ static IrInstruction *ir_build_const_usize(IrBuilder *irb, Scope *scope, AstNode
static IrInstruction *ir_create_const_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
TypeTableEntry *type_entry)
{
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, scope, source_node);
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
const_instruction->base.value.type = irb->codegen->builtin_types.entry_type;
const_instruction->base.value.special = ConstValSpecialStatic;
const_instruction->base.value.data.x_type = type_entry;
@@ -672,7 +673,7 @@ static IrInstruction *ir_build_const_bound_fn(IrBuilder *irb, Scope *scope, AstN
}
static IrInstruction *ir_create_const_str_lit(IrBuilder *irb, Scope *scope, AstNode *source_node, Buf *str) {
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, scope, source_node);
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
init_const_str_lit(irb->codegen, &const_instruction->base.value, str);
return &const_instruction->base;
@@ -863,7 +864,7 @@ static IrInstruction *ir_build_phi_from(IrBuilder *irb, IrInstruction *old_instr
static IrInstruction *ir_create_br(IrBuilder *irb, Scope *scope, AstNode *source_node,
IrBasicBlock *dest_block, IrInstruction *is_comptime)
{
- IrInstructionBr *br_instruction = ir_create_instruction<IrInstructionBr>(irb->exec, scope, source_node);
+ IrInstructionBr *br_instruction = ir_create_instruction<IrInstructionBr>(irb, scope, source_node);
br_instruction->base.value.type = irb->codegen->builtin_types.entry_unreachable;
br_instruction->base.value.special = ConstValSpecialStatic;
br_instruction->dest_block = dest_block;
@@ -1948,6 +1949,777 @@ static IrInstruction *ir_build_int_to_enum(IrBuilder *irb, Scope *scope, AstNode
return &instruction->base;
}
+static IrInstruction *ir_instruction_br_get_dep(IrInstructionBr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->is_comptime;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_condbr_get_dep(IrInstructionCondBr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->condition;
+ case 1: return instruction->is_comptime;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_switchbr_get_dep(IrInstructionSwitchBr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target_value;
+ case 1: return instruction->is_comptime;
+ }
+ size_t case_index = index - 2;
+ if (case_index < instruction->case_count) return instruction->cases[case_index].value;
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_switchvar_get_dep(IrInstructionSwitchVar *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target_value_ptr;
+ case 1: return instruction->prong_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_switchtarget_get_dep(IrInstructionSwitchTarget *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target_value_ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_phi_get_dep(IrInstructionPhi *instruction, size_t index) {
+ if (index < instruction->incoming_count) return instruction->incoming_values[index];
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_unop_get_dep(IrInstructionUnOp *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_binop_get_dep(IrInstructionBinOp *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->op1;
+ case 1: return instruction->op2;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_declvar_get_dep(IrInstructionDeclVar *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->var_type;
+ case 1: return instruction->init_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_loadptr_get_dep(IrInstructionLoadPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_storeptr_get_dep(IrInstructionStorePtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->ptr;
+ case 1: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_fieldptr_get_dep(IrInstructionFieldPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->container_ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_structfieldptr_get_dep(IrInstructionStructFieldPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->struct_ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_enumfieldptr_get_dep(IrInstructionEnumFieldPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->enum_ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_elemptr_get_dep(IrInstructionElemPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->array_ptr;
+ case 1: return instruction->elem_index;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_varptr_get_dep(IrInstructionVarPtr *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_call_get_dep(IrInstructionCall *instruction, size_t index) {
+ if (index == 0) return instruction->fn_ref;
+ size_t arg_index = index - 1;
+ if (arg_index < instruction->arg_count) return instruction->args[arg_index];
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_const_get_dep(IrInstructionConst *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_return_get_dep(IrInstructionReturn *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_cast_get_dep(IrInstructionCast *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_containerinitlist_get_dep(IrInstructionContainerInitList *instruction,
+ size_t index)
+{
+ if (index == 0) return instruction->container_type;
+ size_t item_index = index - 1;
+ if (item_index < instruction->item_count) return instruction->items[item_index];
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_containerinitfields_get_dep(IrInstructionContainerInitFields *instruction,
+ size_t index)
+{
+ if (index == 0) return instruction->container_type;
+ size_t field_index = index - 1;
+ if (field_index < instruction->field_count) return instruction->fields[field_index].value;
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_structinit_get_dep(IrInstructionStructInit *instruction, size_t index) {
+ if (index < instruction->field_count) return instruction->fields[index].value;
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_unreachable_get_dep(IrInstructionUnreachable *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_typeof_get_dep(IrInstructionTypeOf *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_toptrtype_get_dep(IrInstructionToPtrType *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_ptrtypechild_get_dep(IrInstructionPtrTypeChild *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_setfntest_get_dep(IrInstructionSetFnTest *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->fn_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_setfnvisible_get_dep(IrInstructionSetFnVisible *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->fn_value;
+ case 1: return instruction->is_visible;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_setdebugsafety_get_dep(IrInstructionSetDebugSafety *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->scope_value;
+ case 1: return instruction->debug_safety_on;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_arraytype_get_dep(IrInstructionArrayType *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->size;
+ case 1: return instruction->child_type;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_slicetype_get_dep(IrInstructionSliceType *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->child_type;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_asm_get_dep(IrInstructionAsm *instruction, size_t index) {
+ AstNode *asm_node = instruction->base.source_node;
+ if (index < asm_node->data.asm_expr.output_list.length) return instruction->output_types[index];
+ size_t input_index = index - asm_node->data.asm_expr.output_list.length;
+ if (input_index < asm_node->data.asm_expr.input_list.length) return instruction->input_list[input_index];
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_compilevar_get_dep(IrInstructionCompileVar *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_sizeof_get_dep(IrInstructionSizeOf *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->type_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_testnonnull_get_dep(IrInstructionTestNonNull *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_unwrapmaybe_get_dep(IrInstructionUnwrapMaybe *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_maybewrap_get_dep(IrInstructionMaybeWrap *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_enumtag_get_dep(IrInstructionEnumTag *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_clz_get_dep(IrInstructionClz *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_ctz_get_dep(IrInstructionCtz *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_staticeval_get_dep(IrInstructionStaticEval *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_import_get_dep(IrInstructionImport *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_cimport_get_dep(IrInstructionCImport *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_cinclude_get_dep(IrInstructionCInclude *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_cdefine_get_dep(IrInstructionCDefine *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ case 1: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_cundef_get_dep(IrInstructionCUndef *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_arraylen_get_dep(IrInstructionArrayLen *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->array_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_ref_get_dep(IrInstructionRef *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_minvalue_get_dep(IrInstructionMinValue *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_maxvalue_get_dep(IrInstructionMaxValue *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_compileerr_get_dep(IrInstructionCompileErr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->msg;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_errname_get_dep(IrInstructionErrName *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_embedfile_get_dep(IrInstructionEmbedFile *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->name;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_cmpxchg_get_dep(IrInstructionCmpxchg *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->ptr;
+ case 1: return instruction->cmp_value;
+ case 2: return instruction->new_value;
+ case 3: return instruction->success_order_value;
+ case 4: return instruction->failure_order_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_fence_get_dep(IrInstructionFence *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->order_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_divexact_get_dep(IrInstructionDivExact *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->op1;
+ case 1: return instruction->op2;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_truncate_get_dep(IrInstructionTruncate *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->dest_type;
+ case 1: return instruction->target;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_inttype_get_dep(IrInstructionIntType *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->is_signed;
+ case 1: return instruction->bit_count;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_boolnot_get_dep(IrInstructionBoolNot *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_alloca_get_dep(IrInstructionAlloca *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->type_value;
+ case 1: return instruction->count;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_memset_get_dep(IrInstructionMemset *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->dest_ptr;
+ case 1: return instruction->byte;
+ case 2: return instruction->count;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_memcpy_get_dep(IrInstructionMemcpy *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->dest_ptr;
+ case 1: return instruction->src_ptr;
+ case 2: return instruction->count;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_slice_get_dep(IrInstructionSlice *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->ptr;
+ case 1: return instruction->start;
+ case 2: return instruction->end;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_membercount_get_dep(IrInstructionMemberCount *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->container;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_breakpoint_get_dep(IrInstructionBreakpoint *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_returnaddress_get_dep(IrInstructionReturnAddress *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_frameaddress_get_dep(IrInstructionFrameAddress *instruction, size_t index) {
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_alignof_get_dep(IrInstructionAlignOf *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->type_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_overflowop_get_dep(IrInstructionOverflowOp *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->type_value;
+ case 1: return instruction->op1;
+ case 2: return instruction->op2;
+ case 3: return instruction->result_ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_testerr_get_dep(IrInstructionTestErr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_unwraperrcode_get_dep(IrInstructionUnwrapErrCode *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_unwraperrpayload_get_dep(IrInstructionUnwrapErrPayload *instruction,
+ size_t index)
+{
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_errwrapcode_get_dep(IrInstructionErrWrapCode *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_errwrappayload_get_dep(IrInstructionErrWrapPayload *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_fnproto_get_dep(IrInstructionFnProto *instruction, size_t index) {
+ if (index == 0) return instruction->return_type;
+ size_t param_index = index - 1;
+ if (param_index < instruction->base.source_node->data.fn_proto.params.length) {
+ return instruction->param_types[param_index];
+ }
+ return nullptr;
+}
+
+static IrInstruction *ir_instruction_testcomptime_get_dep(IrInstructionTestComptime *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_initenum_get_dep(IrInstructionInitEnum *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->init_value;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_pointerreinterpret_get_dep(IrInstructionPointerReinterpret *instruction,
+ size_t index)
+{
+ switch (index) {
+ case 0: return instruction->ptr;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_widenorshorten_get_dep(IrInstructionWidenOrShorten *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_inttoptr_get_dep(IrInstructionIntToPtr *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_ptrtoint_get_dep(IrInstructionPtrToInt *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_inttoenum_get_dep(IrInstructionIntToEnum *instruction, size_t index) {
+ switch (index) {
+ case 0: return instruction->target;
+ default: return nullptr;
+ }
+}
+
+static IrInstruction *ir_instruction_get_dep(IrInstruction *instruction, size_t index) {
+ switch (instruction->id) {
+ case IrInstructionIdInvalid:
+ zig_unreachable();
+ case IrInstructionIdBr:
+ return ir_instruction_br_get_dep((IrInstructionBr *) instruction, index);
+ case IrInstructionIdCondBr:
+ return ir_instruction_condbr_get_dep((IrInstructionCondBr *) instruction, index);
+ case IrInstructionIdSwitchBr:
+ return ir_instruction_switchbr_get_dep((IrInstructionSwitchBr *) instruction, index);
+ case IrInstructionIdSwitchVar:
+ return ir_instruction_switchvar_get_dep((IrInstructionSwitchVar *) instruction, index);
+ case IrInstructionIdSwitchTarget:
+ return ir_instruction_switchtarget_get_dep((IrInstructionSwitchTarget *) instruction, index);
+ case IrInstructionIdPhi:
+ return ir_instruction_phi_get_dep((IrInstructionPhi *) instruction, index);
+ case IrInstructionIdUnOp:
+ return ir_instruction_unop_get_dep((IrInstructionUnOp *) instruction, index);
+ case IrInstructionIdBinOp:
+ return ir_instruction_binop_get_dep((IrInstructionBinOp *) instruction, index);
+ case IrInstructionIdDeclVar:
+ return ir_instruction_declvar_get_dep((IrInstructionDeclVar *) instruction, index);
+ case IrInstructionIdLoadPtr:
+ return ir_instruction_loadptr_get_dep((IrInstructionLoadPtr *) instruction, index);
+ case IrInstructionIdStorePtr:
+ return ir_instruction_storeptr_get_dep((IrInstructionStorePtr *) instruction, index);
+ case IrInstructionIdFieldPtr:
+ return ir_instruction_fieldptr_get_dep((IrInstructionFieldPtr *) instruction, index);
+ case IrInstructionIdStructFieldPtr:
+ return ir_instruction_structfieldptr_get_dep((IrInstructionStructFieldPtr *) instruction, index);
+ case IrInstructionIdEnumFieldPtr:
+ return ir_instruction_enumfieldptr_get_dep((IrInstructionEnumFieldPtr *) instruction, index);
+ case IrInstructionIdElemPtr:
+ return ir_instruction_elemptr_get_dep((IrInstructionElemPtr *) instruction, index);
+ case IrInstructionIdVarPtr:
+ return ir_instruction_varptr_get_dep((IrInstructionVarPtr *) instruction, index);
+ case IrInstructionIdCall:
+ return ir_instruction_call_get_dep((IrInstructionCall *) instruction, index);
+ case IrInstructionIdConst:
+ return ir_instruction_const_get_dep((IrInstructionConst *) instruction, index);
+ case IrInstructionIdReturn:
+ return ir_instruction_return_get_dep((IrInstructionReturn *) instruction, index);
+ case IrInstructionIdCast:
+ return ir_instruction_cast_get_dep((IrInstructionCast *) instruction, index);
+ case IrInstructionIdContainerInitList:
+ return ir_instruction_containerinitlist_get_dep((IrInstructionContainerInitList *) instruction, index);
+ case IrInstructionIdContainerInitFields:
+ return ir_instruction_containerinitfields_get_dep((IrInstructionContainerInitFields *) instruction, index);
+ case IrInstructionIdStructInit:
+ return ir_instruction_structinit_get_dep((IrInstructionStructInit *) instruction, index);
+ case IrInstructionIdUnreachable:
+ return ir_instruction_unreachable_get_dep((IrInstructionUnreachable *) instruction, index);
+ case IrInstructionIdTypeOf:
+ return ir_instruction_typeof_get_dep((IrInstructionTypeOf *) instruction, index);
+ case IrInstructionIdToPtrType:
+ return ir_instruction_toptrtype_get_dep((IrInstructionToPtrType *) instruction, index);
+ case IrInstructionIdPtrTypeChild:
+ return ir_instruction_ptrtypechild_get_dep((IrInstructionPtrTypeChild *) instruction, index);
+ case IrInstructionIdSetFnTest:
+ return ir_instruction_setfntest_get_dep((IrInstructionSetFnTest *) instruction, index);
+ case IrInstructionIdSetFnVisible:
+ return ir_instruction_setfnvisible_get_dep((IrInstructionSetFnVisible *) instruction, index);
+ case IrInstructionIdSetDebugSafety:
+ return ir_instruction_setdebugsafety_get_dep((IrInstructionSetDebugSafety *) instruction, index);
+ case IrInstructionIdArrayType:
+ return ir_instruction_arraytype_get_dep((IrInstructionArrayType *) instruction, index);
+ case IrInstructionIdSliceType:
+ return ir_instruction_slicetype_get_dep((IrInstructionSliceType *) instruction, index);
+ case IrInstructionIdAsm:
+ return ir_instruction_asm_get_dep((IrInstructionAsm *) instruction, index);
+ case IrInstructionIdCompileVar:
+ return ir_instruction_compilevar_get_dep((IrInstructionCompileVar *) instruction, index);
+ case IrInstructionIdSizeOf:
+ return ir_instruction_sizeof_get_dep((IrInstructionSizeOf *) instruction, index);
+ case IrInstructionIdTestNonNull:
+ return ir_instruction_testnonnull_get_dep((IrInstructionTestNonNull *) instruction, index);
+ case IrInstructionIdUnwrapMaybe:
+ return ir_instruction_unwrapmaybe_get_dep((IrInstructionUnwrapMaybe *) instruction, index);
+ case IrInstructionIdMaybeWrap:
+ return ir_instruction_maybewrap_get_dep((IrInstructionMaybeWrap *) instruction, index);
+ case IrInstructionIdEnumTag:
+ return ir_instruction_enumtag_get_dep((IrInstructionEnumTag *) instruction, index);
+ case IrInstructionIdClz:
+ return ir_instruction_clz_get_dep((IrInstructionClz *) instruction, index);
+ case IrInstructionIdCtz:
+ return ir_instruction_ctz_get_dep((IrInstructionCtz *) instruction, index);
+ case IrInstructionIdStaticEval:
+ return ir_instruction_staticeval_get_dep((IrInstructionStaticEval *) instruction, index);
+ case IrInstructionIdImport:
+ return ir_instruction_import_get_dep((IrInstructionImport *) instruction, index);
+ case IrInstructionIdCImport:
+ return ir_instruction_cimport_get_dep((IrInstructionCImport *) instruction, index);
+ case IrInstructionIdCInclude:
+ return ir_instruction_cinclude_get_dep((IrInstructionCInclude *) instruction, index);
+ case IrInstructionIdCDefine:
+ return ir_instruction_cdefine_get_dep((IrInstructionCDefine *) instruction, index);
+ case IrInstructionIdCUndef:
+ return ir_instruction_cundef_get_dep((IrInstructionCUndef *) instruction, index);
+ case IrInstructionIdArrayLen:
+ return ir_instruction_arraylen_get_dep((IrInstructionArrayLen *) instruction, index);
+ case IrInstructionIdRef:
+ return ir_instruction_ref_get_dep((IrInstructionRef *) instruction, index);
+ case IrInstructionIdMinValue:
+ return ir_instruction_minvalue_get_dep((IrInstructionMinValue *) instruction, index);
+ case IrInstructionIdMaxValue:
+ return ir_instruction_maxvalue_get_dep((IrInstructionMaxValue *) instruction, index);
+ case IrInstructionIdCompileErr:
+ return ir_instruction_compileerr_get_dep((IrInstructionCompileErr *) instruction, index);
+ case IrInstructionIdErrName:
+ return ir_instruction_errname_get_dep((IrInstructionErrName *) instruction, index);
+ case IrInstructionIdEmbedFile:
+ return ir_instruction_embedfile_get_dep((IrInstructionEmbedFile *) instruction, index);
+ case IrInstructionIdCmpxchg:
+ return ir_instruction_cmpxchg_get_dep((IrInstructionCmpxchg *) instruction, index);
+ case IrInstructionIdFence:
+ return ir_instruction_fence_get_dep((IrInstructionFence *) instruction, index);
+ case IrInstructionIdDivExact:
+ return ir_instruction_divexact_get_dep((IrInstructionDivExact *) instruction, index);
+ case IrInstructionIdTruncate:
+ return ir_instruction_truncate_get_dep((IrInstructionTruncate *) instruction, index);
+ case IrInstructionIdIntType:
+ return ir_instruction_inttype_get_dep((IrInstructionIntType *) instruction, index);
+ case IrInstructionIdBoolNot:
+ return ir_instruction_boolnot_get_dep((IrInstructionBoolNot *) instruction, index);
+ case IrInstructionIdAlloca:
+ return ir_instruction_alloca_get_dep((IrInstructionAlloca *) instruction, index);
+ case IrInstructionIdMemset:
+ return ir_instruction_memset_get_dep((IrInstructionMemset *) instruction, index);
+ case IrInstructionIdMemcpy:
+ return ir_instruction_memcpy_get_dep((IrInstructionMemcpy *) instruction, index);
+ case IrInstructionIdSlice:
+ return ir_instruction_slice_get_dep((IrInstructionSlice *) instruction, index);
+ case IrInstructionIdMemberCount:
+ return ir_instruction_membercount_get_dep((IrInstructionMemberCount *) instruction, index);
+ case IrInstructionIdBreakpoint:
+ return ir_instruction_breakpoint_get_dep((IrInstructionBreakpoint *) instruction, index);
+ case IrInstructionIdReturnAddress:
+ return ir_instruction_returnaddress_get_dep((IrInstructionReturnAddress *) instruction, index);
+ case IrInstructionIdFrameAddress:
+ return ir_instruction_frameaddress_get_dep((IrInstructionFrameAddress *) instruction, index);
+ case IrInstructionIdAlignOf:
+ return ir_instruction_alignof_get_dep((IrInstructionAlignOf *) instruction, index);
+ case IrInstructionIdOverflowOp:
+ return ir_instruction_overflowop_get_dep((IrInstructionOverflowOp *) instruction, index);
+ case IrInstructionIdTestErr:
+ return ir_instruction_testerr_get_dep((IrInstructionTestErr *) instruction, index);
+ case IrInstructionIdUnwrapErrCode:
+ return ir_instruction_unwraperrcode_get_dep((IrInstructionUnwrapErrCode *) instruction, index);
+ case IrInstructionIdUnwrapErrPayload:
+ return ir_instruction_unwraperrpayload_get_dep((IrInstructionUnwrapErrPayload *) instruction, index);
+ case IrInstructionIdErrWrapCode:
+ return ir_instruction_errwrapcode_get_dep((IrInstructionErrWrapCode *) instruction, index);
+ case IrInstructionIdErrWrapPayload:
+ return ir_instruction_errwrappayload_get_dep((IrInstructionErrWrapPayload *) instruction, index);
+ case IrInstructionIdFnProto:
+ return ir_instruction_fnproto_get_dep((IrInstructionFnProto *) instruction, index);
+ case IrInstructionIdTestComptime:
+ return ir_instruction_testcomptime_get_dep((IrInstructionTestComptime *) instruction, index);
+ case IrInstructionIdInitEnum:
+ return ir_instruction_initenum_get_dep((IrInstructionInitEnum *) instruction, index);
+ case IrInstructionIdPointerReinterpret:
+ return ir_instruction_pointerreinterpret_get_dep((IrInstructionPointerReinterpret *) instruction, index);
+ case IrInstructionIdWidenOrShorten:
+ return ir_instruction_widenorshorten_get_dep((IrInstructionWidenOrShorten *) instruction, index);
+ case IrInstructionIdIntToPtr:
+ return ir_instruction_inttoptr_get_dep((IrInstructionIntToPtr *) instruction, index);
+ case IrInstructionIdPtrToInt:
+ return ir_instruction_ptrtoint_get_dep((IrInstructionPtrToInt *) instruction, index);
+ case IrInstructionIdIntToEnum:
+ return ir_instruction_inttoenum_get_dep((IrInstructionIntToEnum *) instruction, index);
+ }
+ zig_unreachable();
+}
+
static void ir_count_defers(IrBuilder *irb, Scope *inner_scope, Scope *outer_scope, size_t *results) {
results[ReturnKindUnconditional] = 0;
results[ReturnKindError] = 0;
@@ -4804,23 +5576,24 @@ static bool is_u8(TypeTableEntry *type) {
}
static IrBasicBlock *ir_get_new_bb(IrAnalyze *ira, IrBasicBlock *old_bb) {
+ assert(old_bb);
+
if (old_bb->other)
return old_bb->other;
IrBasicBlock *new_bb = ir_build_bb_from(&ira->new_irb, old_bb);
- // We are about to enqueue old_bb for analysis. Before we do so, check old_bb
- // for phi instructions. Any incoming blocks in the phi instructions need to be
- // queued first.
+ // We are about to enqueue old_bb for analysis. Before we do so, look over old_bb's
+ // instructions and make sure we have enqueued first the blocks which contain
+ // instructions old_bb depends on.
for (size_t instr_i = 0; instr_i < old_bb->instruction_list.length; instr_i += 1) {
IrInstruction *instruction = old_bb->instruction_list.at(instr_i);
- if (instruction->id != IrInstructionIdPhi)
- break;
- IrInstructionPhi *phi_instruction = (IrInstructionPhi *)instruction;
- for (size_t incoming_i = 0; incoming_i < phi_instruction->incoming_count; incoming_i += 1) {
- IrBasicBlock *predecessor = phi_instruction->incoming_blocks[incoming_i];
- IrBasicBlock *new_predecessor = ir_get_new_bb(ira, predecessor);
- ir_ref_bb(new_predecessor);
+
+ for (size_t dep_i = 0; ; dep_i += 1) {
+ IrInstruction *dep_instruction = ir_instruction_get_dep(instruction, dep_i);
+ if (dep_instruction == nullptr)
+ break;
+ ir_get_new_bb(ira, dep_instruction->owner_bb);
}
}
ira->old_bb_queue.append(old_bb);
@@ -4892,20 +5665,20 @@ static ConstExprValue *ir_build_const_from(IrAnalyze *ira, IrInstruction *old_in
IrInstruction *new_instruction;
if (old_instruction->id == IrInstructionIdVarPtr) {
IrInstructionVarPtr *old_var_ptr_instruction = (IrInstructionVarPtr *)old_instruction;
- IrInstructionVarPtr *var_ptr_instruction = ir_create_instruction<IrInstructionVarPtr>(ira->new_irb.exec,
+ IrInstructionVarPtr *var_ptr_instruction = ir_create_instruction<IrInstructionVarPtr>(&ira->new_irb,
old_instruction->scope, old_instruction->source_node);
var_ptr_instruction->var = old_var_ptr_instruction->var;
new_instruction = &var_ptr_instruction->base;
} else if (old_instruction->id == IrInstructionIdFieldPtr) {
- IrInstructionFieldPtr *field_ptr_instruction = ir_create_instruction<IrInstructionFieldPtr>(ira->new_irb.exec,
+ IrInstructionFieldPtr *field_ptr_instruction = ir_create_instruction<IrInstructionFieldPtr>(&ira->new_irb,
old_instruction->scope, old_instruction->source_node);
new_instruction = &field_ptr_instruction->base;
} else if (old_instruction->id == IrInstructionIdElemPtr) {
- IrInstructionElemPtr *elem_ptr_instruction = ir_create_instruction<IrInstructionElemPtr>(ira->new_irb.exec,
+ IrInstructionElemPtr *elem_ptr_instruction = ir_create_instruction<IrInstructionElemPtr>(&ira->new_irb,
old_instruction->scope, old_instruction->source_node);
new_instruction = &elem_ptr_instruction->base;
} else {
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
old_instruction->scope, old_instruction->source_node);
new_instruction = &const_instruction->base;
}
@@ -5079,7 +5852,7 @@ static IrInstruction *ir_analyze_maybe_wrap(IrAnalyze *ira, IrInstruction *sourc
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = wanted_type;
const_instruction->base.value.special = ConstValSpecialStatic;
@@ -5110,7 +5883,7 @@ static IrInstruction *ir_analyze_pointer_reinterpret(IrAnalyze *ira, IrInstructi
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value = *val;
const_instruction->base.value.type = wanted_type;
@@ -5138,7 +5911,7 @@ static IrInstruction *ir_analyze_err_wrap_payload(IrAnalyze *ira, IrInstruction
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = wanted_type;
const_instruction->base.value.special = ConstValSpecialStatic;
@@ -5163,7 +5936,7 @@ static IrInstruction *ir_analyze_err_wrap_code(IrAnalyze *ira, IrInstruction *so
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = wanted_type;
const_instruction->base.value.special = ConstValSpecialStatic;
@@ -5186,7 +5959,7 @@ static IrInstruction *ir_analyze_cast_ref(IrAnalyze *ira, IrInstruction *source_
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = wanted_type;
const_instruction->base.value.special = ConstValSpecialStatic;
@@ -5220,7 +5993,7 @@ static IrInstruction *ir_analyze_null_to_maybe(IrAnalyze *ira, IrInstruction *so
ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
assert(val);
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec, source_instr->scope, source_instr->source_node);
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = wanted_type;
const_instruction->base.value.special = ConstValSpecialStatic;
const_instruction->base.value.depends_on_compile_var = val->depends_on_compile_var;
@@ -8309,7 +9082,7 @@ static IrInstruction *ir_analyze_enum_tag(IrAnalyze *ira, IrInstruction *source_
if (!val)
return ira->codegen->invalid_instruction;
- IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(ira->new_irb.exec,
+ IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
source_instr->scope, source_instr->source_node);
const_instruction->base.value.type = value->value.type->data.enumeration.tag_type;
const_instruction->base.value.special = ConstValSpecialStatic;
test/cases/ir_block_deps.zig
@@ -0,0 +1,27 @@
+fn foo(id: u64) -> %i32 {
+ return switch (id) {
+ 1 => getErrInt(),
+ 2 => {
+ const size = %return getErrInt();
+ return %return getErrInt();
+ },
+ else => error.ItBroke,
+ }
+}
+
+fn getErrInt() -> %i32 { 0 }
+
+error ItBroke;
+
+fn irBlockDeps() {
+ @setFnTest(this);
+
+ assert(%%foo(1) == 0);
+ assert(%%foo(2) == 0);
+}
+
+// TODO const assert = @import("std").debug.assert;
+fn assert(ok: bool) {
+ if (!ok)
+ @unreachable();
+}
test/self_hosted.zig
@@ -15,6 +15,7 @@ const test_generics = @import("cases/generics.zig");
const test_goto = @import("cases/goto.zig");
const test_if = @import("cases/if.zig");
const test_import = @import("cases/import.zig");
+const test_ir_block_deps = @import("cases/ir_block_deps.zig");
const test_math = @import("cases/math.zig");
const test_misc = @import("cases/misc.zig");
const test_namespace_depends_on_compile_var = @import("cases/namespace_depends_on_compile_var/index.zig");