| ... | @@ -154,7 +154,6 @@ struct ConstCastBadAllowsZero { | ... | @@ -154,7 +154,6 @@ struct ConstCastBadAllowsZero { |
| 154 | enum UndefAllowed { | 154 | enum UndefAllowed { |
| 155 | UndefOk, | 155 | UndefOk, |
| 156 | UndefBad, | 156 | UndefBad, |
| 157 | LazyOk, | | |
| 158 | }; | 157 | }; |
| 159 | | 158 | |
| 160 | static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope); | 159 | static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope); |
| ... | @@ -10257,57 +10256,32 @@ static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instructio | ... | @@ -10257,57 +10256,32 @@ static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instructio |
| 10257 | return const_instr; | 10256 | return const_instr; |
| 10258 | } | 10257 | } |
| 10259 | | 10258 | |
| 10260 | static Error ir_resolve_const_val(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, | | |
| 10261 | ConstExprValue *val, UndefAllowed undef_allowed) | | |
| 10262 | { | | |
| 10263 | Error err; | | |
| 10264 | for (;;) { | | |
| 10265 | switch (val->special) { | | |
| 10266 | case ConstValSpecialStatic: | | |
| 10267 | return ErrorNone; | | |
| 10268 | case ConstValSpecialRuntime: | | |
| 10269 | if (!type_has_bits(val->type)) | | |
| 10270 | return ErrorNone; | | |
| 10271 | | | |
| 10272 | exec_add_error_node(codegen, exec, source_node, | | |
| 10273 | buf_sprintf("unable to evaluate constant expression")); | | |
| 10274 | return ErrorSemanticAnalyzeFail; | | |
| 10275 | case ConstValSpecialUndef: | | |
| 10276 | if (undef_allowed == UndefOk) | | |
| 10277 | return ErrorNone; | | |
| 10278 | | | |
| 10279 | exec_add_error_node(codegen, exec, source_node, | | |
| 10280 | buf_sprintf("use of undefined value here causes undefined behavior")); | | |
| 10281 | return ErrorSemanticAnalyzeFail; | | |
| 10282 | case ConstValSpecialLazy: | | |
| 10283 | if (undef_allowed == LazyOk) | | |
| 10284 | return ErrorNone; | | |
| 10285 | | | |
| 10286 | if ((err = ir_resolve_lazy(codegen, source_node, val))) | | |
| 10287 | return err; | | |
| 10288 | | | |
| 10289 | continue; | | |
| 10290 | } | | |
| 10291 | } | | |
| 10292 | } | | |
| 10293 | | | |
| 10294 | static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, UndefAllowed undef_allowed) { | 10259 | static ConstExprValue *ir_resolve_const(IrAnalyze *ira, IrInstruction *value, UndefAllowed undef_allowed) { |
| 10295 | Error err; | 10260 | switch (value->value.special) { |
| 10296 | if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, value->source_node, | 10261 | case ConstValSpecialStatic: |
| 10297 | &value->value, undef_allowed))) | 10262 | return &value->value; |
| 10298 | { | 10263 | case ConstValSpecialRuntime: |
| 10299 | return nullptr; | 10264 | if (!type_has_bits(value->value.type)) { |
| | 10265 | return &value->value; |
| | 10266 | } |
| | 10267 | ir_add_error(ira, value, buf_sprintf("unable to evaluate constant expression")); |
| | 10268 | return nullptr; |
| | 10269 | case ConstValSpecialUndef: |
| | 10270 | if (undef_allowed == UndefOk) { |
| | 10271 | return &value->value; |
| | 10272 | } else { |
| | 10273 | ir_add_error(ira, value, buf_sprintf("use of undefined value here causes undefined behavior")); |
| | 10274 | return nullptr; |
| | 10275 | } |
| 10300 | } | 10276 | } |
| 10301 | return &value->value; | 10277 | zig_unreachable(); |
| 10302 | } | 10278 | } |
| 10303 | | 10279 | |
| 10304 | ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node, | 10280 | ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node, |
| 10305 | ZigType *expected_type, size_t *backward_branch_count, size_t backward_branch_quota, | 10281 | ZigType *expected_type, size_t *backward_branch_count, size_t backward_branch_quota, |
| 10306 | ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name, | 10282 | ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name, |
| 10307 | IrExecutable *parent_exec, AstNode *expected_type_source_node, bool allow_lazy) | 10283 | IrExecutable *parent_exec, AstNode *expected_type_source_node) |
| 10308 | { | 10284 | { |
| 10309 | Error err; | | |
| 10310 | | | |
| 10311 | if (expected_type != nullptr && type_is_invalid(expected_type)) | 10285 | if (expected_type != nullptr && type_is_invalid(expected_type)) |
| 10312 | return &codegen->invalid_instruction->value; | 10286 | return &codegen->invalid_instruction->value; |
| 10313 | | 10287 | |
| ... | @@ -10352,24 +10326,7 @@ ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *nod | ... | @@ -10352,24 +10326,7 @@ ConstExprValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *nod |
| 10352 | fprintf(stderr, "}\n"); | 10326 | fprintf(stderr, "}\n"); |
| 10353 | } | 10327 | } |
| 10354 | | 10328 | |
| 10355 | ConstExprValue *result = ir_exec_const_result(codegen, analyzed_executable); | 10329 | return ir_exec_const_result(codegen, analyzed_executable); |
| 10356 | | | |
| 10357 | if (!allow_lazy) { | | |
| 10358 | if ((err = ir_resolve_lazy(codegen, node, result))) | | |
| 10359 | return &codegen->invalid_instruction->value; | | |
| 10360 | } | | |
| 10361 | return result; | | |
| 10362 | } | | |
| 10363 | | | |
| 10364 | static ZigType *ir_resolve_const_type(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, | | |
| 10365 | ConstExprValue *val) | | |
| 10366 | { | | |
| 10367 | Error err; | | |
| 10368 | if ((err = ir_resolve_const_val(codegen, exec, source_node, val, UndefBad))) | | |
| 10369 | return codegen->builtin_types.entry_invalid; | | |
| 10370 | | | |
| 10371 | assert(val->data.x_type != nullptr); | | |
| 10372 | return val->data.x_type; | | |
| 10373 | } | 10330 | } |
| 10374 | | 10331 | |
| 10375 | static ZigType *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value) { | 10332 | static ZigType *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value) { |
| ... | @@ -10382,7 +10339,12 @@ static ZigType *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value) { | ... | @@ -10382,7 +10339,12 @@ static ZigType *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value) { |
| 10382 | return ira->codegen->builtin_types.entry_invalid; | 10339 | return ira->codegen->builtin_types.entry_invalid; |
| 10383 | } | 10340 | } |
| 10384 | | 10341 | |
| 10385 | return ir_resolve_const_type(ira->codegen, ira->new_irb.exec, type_value->source_node, &type_value->value); | 10342 | ConstExprValue *const_val = ir_resolve_const(ira, type_value, UndefBad); |
| | 10343 | if (!const_val) |
| | 10344 | return ira->codegen->builtin_types.entry_invalid; |
| | 10345 | |
| | 10346 | assert(const_val->data.x_type != nullptr); |
| | 10347 | return const_val->data.x_type; |
| 10386 | } | 10348 | } |
| 10387 | | 10349 | |
| 10388 | static ZigType *ir_resolve_error_set_type(IrAnalyze *ira, IrInstruction *op_source, IrInstruction *type_value) { | 10350 | static ZigType *ir_resolve_error_set_type(IrAnalyze *ira, IrInstruction *op_source, IrInstruction *type_value) { |
| ... | @@ -11873,38 +11835,33 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc | ... | @@ -11873,38 +11835,33 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc |
| 11873 | } | 11835 | } |
| 11874 | } | 11836 | } |
| 11875 | | 11837 | |
| 11876 | static bool ir_resolve_const_align(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, | 11838 | static bool ir_resolve_align(IrAnalyze *ira, IrInstruction *value, uint32_t *out) { |
| 11877 | ConstExprValue *const_val, uint32_t *out) | 11839 | if (type_is_invalid(value->value.type)) |
| 11878 | { | 11840 | return false; |
| 11879 | Error err; | 11841 | |
| 11880 | if ((err = ir_resolve_const_val(codegen, exec, source_node, const_val, UndefBad))) | 11842 | IrInstruction *casted_value = ir_implicit_cast(ira, value, get_align_amt_type(ira->codegen)); |
| | 11843 | if (type_is_invalid(casted_value->value.type)) |
| | 11844 | return false; |
| | 11845 | |
| | 11846 | ConstExprValue *const_val = ir_resolve_const(ira, casted_value, UndefBad); |
| | 11847 | if (!const_val) |
| 11881 | return false; | 11848 | return false; |
| 11882 | | 11849 | |
| 11883 | uint32_t align_bytes = bigint_as_unsigned(&const_val->data.x_bigint); | 11850 | uint32_t align_bytes = bigint_as_unsigned(&const_val->data.x_bigint); |
| 11884 | if (align_bytes == 0) { | 11851 | if (align_bytes == 0) { |
| 11885 | exec_add_error_node(codegen, exec, source_node, buf_sprintf("alignment must be >= 1")); | 11852 | ir_add_error(ira, value, buf_sprintf("alignment must be >= 1")); |
| 11886 | return false; | 11853 | return false; |
| 11887 | } | 11854 | } |
| 11888 | | 11855 | |
| 11889 | if (!is_power_of_2(align_bytes)) { | 11856 | if (!is_power_of_2(align_bytes)) { |
| 11890 | exec_add_error_node(codegen, exec, source_node, buf_sprintf("alignment value %" PRIu32 " is not a power of 2", align_bytes)); | 11857 | ir_add_error(ira, value, buf_sprintf("alignment value %" PRIu32 " is not a power of 2", align_bytes)); |
| 11891 | return false; | 11858 | return false; |
| 11892 | } | 11859 | } |
| | 11860 | |
| 11893 | *out = align_bytes; | 11861 | *out = align_bytes; |
| 11894 | return true; | 11862 | return true; |
| 11895 | } | 11863 | } |
| 11896 | | 11864 | |
| 11897 | static bool ir_resolve_align(IrAnalyze *ira, IrInstruction *value, uint32_t *out) { | | |
| 11898 | if (type_is_invalid(value->value.type)) | | |
| 11899 | return false; | | |
| 11900 | | | |
| 11901 | IrInstruction *casted_value = ir_implicit_cast(ira, value, get_align_amt_type(ira->codegen)); | | |
| 11902 | if (type_is_invalid(casted_value->value.type)) | | |
| 11903 | return false; | | |
| 11904 | | | |
| 11905 | return ir_resolve_const_align(ira->codegen, ira->new_irb.exec, value->source_node, &casted_value->value, out); | | |
| 11906 | } | | |
| 11907 | | | |
| 11908 | static bool ir_resolve_unsigned(IrAnalyze *ira, IrInstruction *value, ZigType *int_type, uint64_t *out) { | 11865 | static bool ir_resolve_unsigned(IrAnalyze *ira, IrInstruction *value, ZigType *int_type, uint64_t *out) { |
| 11909 | if (type_is_invalid(value->value.type)) | 11866 | if (type_is_invalid(value->value.type)) |
| 11910 | return false; | 11867 | return false; |
| ... | @@ -12072,140 +12029,6 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) { | ... | @@ -12072,140 +12029,6 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) { |
| 12072 | return result; | 12029 | return result; |
| 12073 | } | 12030 | } |
| 12074 | | 12031 | |
| 12075 | static ZigType *ir_resolve_lazy_fn_type(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, | | |
| 12076 | LazyValueFnType *lazy_fn_type) | | |
| 12077 | { | | |
| 12078 | AstNode *proto_node = lazy_fn_type->proto_node; | | |
| 12079 | | | |
| 12080 | FnTypeId fn_type_id = {0}; | | |
| 12081 | init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length); | | |
| 12082 | | | |
| 12083 | for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) { | | |
| 12084 | AstNode *param_node = proto_node->data.fn_proto.params.at(fn_type_id.next_param_index); | | |
| 12085 | assert(param_node->type == NodeTypeParamDecl); | | |
| 12086 | | | |
| 12087 | bool param_is_var_args = param_node->data.param_decl.is_var_args; | | |
| 12088 | if (param_is_var_args) { | | |
| 12089 | if (fn_type_id.cc == CallingConventionC) { | | |
| 12090 | fn_type_id.param_count = fn_type_id.next_param_index; | | |
| 12091 | continue; | | |
| 12092 | } else if (fn_type_id.cc == CallingConventionUnspecified) { | | |
| 12093 | return get_generic_fn_type(codegen, &fn_type_id); | | |
| 12094 | } else { | | |
| 12095 | zig_unreachable(); | | |
| 12096 | } | | |
| 12097 | } | | |
| 12098 | FnTypeParamInfo *param_info = &fn_type_id.param_info[fn_type_id.next_param_index]; | | |
| 12099 | param_info->is_noalias = param_node->data.param_decl.is_noalias; | | |
| 12100 | | | |
| 12101 | if (lazy_fn_type->param_types[fn_type_id.next_param_index] == nullptr) { | | |
| 12102 | param_info->type = nullptr; | | |
| 12103 | return get_generic_fn_type(codegen, &fn_type_id); | | |
| 12104 | } else { | | |
| 12105 | ZigType *param_type = ir_resolve_const_type(codegen, exec, source_node, | | |
| 12106 | lazy_fn_type->param_types[fn_type_id.next_param_index]); | | |
| 12107 | if (type_is_invalid(param_type)) | | |
| 12108 | return nullptr; | | |
| 12109 | switch (type_requires_comptime(codegen, param_type)) { | | |
| 12110 | case ReqCompTimeYes: | | |
| 12111 | if (!calling_convention_allows_zig_types(fn_type_id.cc)) { | | |
| 12112 | exec_add_error_node(codegen, exec, source_node, | | |
| 12113 | buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'", | | |
| 12114 | buf_ptr(¶m_type->name), calling_convention_name(fn_type_id.cc))); | | |
| 12115 | return nullptr; | | |
| 12116 | } | | |
| 12117 | param_info->type = param_type; | | |
| 12118 | fn_type_id.next_param_index += 1; | | |
| 12119 | return get_generic_fn_type(codegen, &fn_type_id); | | |
| 12120 | case ReqCompTimeInvalid: | | |
| 12121 | return nullptr; | | |
| 12122 | case ReqCompTimeNo: | | |
| 12123 | break; | | |
| 12124 | } | | |
| 12125 | if (!type_has_bits(param_type) && !calling_convention_allows_zig_types(fn_type_id.cc)) { | | |
| 12126 | exec_add_error_node(codegen, exec, source_node, | | |
| 12127 | buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'", | | |
| 12128 | buf_ptr(¶m_type->name), calling_convention_name(fn_type_id.cc))); | | |
| 12129 | return nullptr; | | |
| 12130 | } | | |
| 12131 | param_info->type = param_type; | | |
| 12132 | } | | |
| 12133 | | | |
| 12134 | } | | |
| 12135 | | | |
| 12136 | if (lazy_fn_type->align_val != nullptr) { | | |
| 12137 | if (!ir_resolve_const_align(codegen, exec, source_node, lazy_fn_type->align_val, &fn_type_id.alignment)) | | |
| 12138 | return nullptr; | | |
| 12139 | } | | |
| 12140 | | | |
| 12141 | fn_type_id.return_type = ir_resolve_const_type(codegen, exec, source_node, lazy_fn_type->return_type); | | |
| 12142 | if (type_is_invalid(fn_type_id.return_type)) | | |
| 12143 | return nullptr; | | |
| 12144 | if (fn_type_id.return_type->id == ZigTypeIdOpaque) { | | |
| 12145 | exec_add_error_node(codegen, exec, source_node, | | |
| 12146 | buf_sprintf("return type cannot be opaque")); | | |
| 12147 | return nullptr; | | |
| 12148 | } | | |
| 12149 | | | |
| 12150 | if (lazy_fn_type->async_allocator_type != nullptr) { | | |
| 12151 | fn_type_id.async_allocator_type = ir_resolve_const_type(codegen, exec, source_node, | | |
| 12152 | lazy_fn_type->async_allocator_type); | | |
| 12153 | if (type_is_invalid(fn_type_id.async_allocator_type)) | | |
| 12154 | return nullptr; | | |
| 12155 | } | | |
| 12156 | | | |
| 12157 | return get_fn_type(codegen, &fn_type_id); | | |
| 12158 | } | | |
| 12159 | | | |
| 12160 | Error ir_resolve_lazy(CodeGen *codegen, AstNode *source_node, ConstExprValue *val) { | | |
| 12161 | Error err; | | |
| 12162 | if (val->special != ConstValSpecialLazy) | | |
| 12163 | return ErrorNone; | | |
| 12164 | IrExecutable *exec = val->data.x_lazy->exec; | | |
| 12165 | switch (val->data.x_lazy->id) { | | |
| 12166 | case LazyValueIdInvalid: | | |
| 12167 | zig_unreachable(); | | |
| 12168 | case LazyValueIdAlignOf: { | | |
| 12169 | LazyValueAlignOf *lazy_align_of = reinterpret_cast<LazyValueAlignOf *>(val->data.x_lazy); | | |
| 12170 | if ((err = type_resolve(codegen, lazy_align_of->target_type, ResolveStatusAlignmentKnown))) | | |
| 12171 | return err; | | |
| 12172 | uint64_t align_in_bytes = get_abi_alignment(codegen, lazy_align_of->target_type); | | |
| 12173 | val->special = ConstValSpecialStatic; | | |
| 12174 | assert(val->type->id == ZigTypeIdComptimeInt); | | |
| 12175 | bigint_init_unsigned(&val->data.x_bigint, align_in_bytes); | | |
| 12176 | return ErrorNone; | | |
| 12177 | } | | |
| 12178 | case LazyValueIdSliceType: { | | |
| 12179 | LazyValueSliceType *lazy_slice_type = reinterpret_cast<LazyValueSliceType *>(val->data.x_lazy); | | |
| 12180 | uint32_t align_bytes = 0; | | |
| 12181 | if (lazy_slice_type->align_val != nullptr) { | | |
| 12182 | if (!ir_resolve_const_align(codegen, exec, source_node, lazy_slice_type->align_val, &align_bytes)) | | |
| 12183 | return ErrorSemanticAnalyzeFail; | | |
| 12184 | } | | |
| 12185 | if ((err = type_resolve(codegen, lazy_slice_type->elem_type, ResolveStatusZeroBitsKnown))) | | |
| 12186 | return err; | | |
| 12187 | ZigType *slice_ptr_type = get_pointer_to_type_extra(codegen, lazy_slice_type->elem_type, | | |
| 12188 | lazy_slice_type->is_const, lazy_slice_type->is_volatile, PtrLenUnknown, align_bytes, | | |
| 12189 | 0, 0, lazy_slice_type->is_allowzero); | | |
| 12190 | val->special = ConstValSpecialStatic; | | |
| 12191 | assert(val->type->id == ZigTypeIdMetaType); | | |
| 12192 | val->data.x_type = get_slice_type(codegen, slice_ptr_type); | | |
| 12193 | return ErrorNone; | | |
| 12194 | } | | |
| 12195 | case LazyValueIdFnType: { | | |
| 12196 | ZigType *fn_type = ir_resolve_lazy_fn_type(codegen, exec, source_node, | | |
| 12197 | reinterpret_cast<LazyValueFnType *>(val->data.x_lazy)); | | |
| 12198 | if (fn_type == nullptr) | | |
| 12199 | return ErrorSemanticAnalyzeFail; | | |
| 12200 | val->special = ConstValSpecialStatic; | | |
| 12201 | assert(val->type->id == ZigTypeIdMetaType); | | |
| 12202 | val->data.x_type = fn_type; | | |
| 12203 | return ErrorNone; | | |
| 12204 | } | | |
| 12205 | } | | |
| 12206 | zig_unreachable(); | | |
| 12207 | } | | |
| 12208 | | | |
| 12209 | static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira, | 12032 | static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira, |
| 12210 | IrInstructionAddImplicitReturnType *instruction) | 12033 | IrInstructionAddImplicitReturnType *instruction) |
| 12211 | { | 12034 | { |
| ... | @@ -14179,7 +14002,7 @@ static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction, | ... | @@ -14179,7 +14002,7 @@ static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction, |
| 14179 | if (linkage_makes_it_runtime) | 14002 | if (linkage_makes_it_runtime) |
| 14180 | goto no_mem_slot; | 14003 | goto no_mem_slot; |
| 14181 | | 14004 | |
| 14182 | if (value_is_comptime(var->const_value)) { | 14005 | if (var->const_value->special == ConstValSpecialStatic) { |
| 14183 | mem_slot = var->const_value; | 14006 | mem_slot = var->const_value; |
| 14184 | } else { | 14007 | } else { |
| 14185 | if (var->mem_slot_index != SIZE_MAX && (comptime_var_mem || var->gen_is_const)) { | 14008 | if (var->mem_slot_index != SIZE_MAX && (comptime_var_mem || var->gen_is_const)) { |
| ... | @@ -14197,7 +14020,6 @@ static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction, | ... | @@ -14197,7 +14020,6 @@ static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction, |
| 14197 | case ConstValSpecialRuntime: | 14020 | case ConstValSpecialRuntime: |
| 14198 | goto no_mem_slot; | 14021 | goto no_mem_slot; |
| 14199 | case ConstValSpecialStatic: // fallthrough | 14022 | case ConstValSpecialStatic: // fallthrough |
| 14200 | case ConstValSpecialLazy: // fallthrough | | |
| 14201 | case ConstValSpecialUndef: { | 14023 | case ConstValSpecialUndef: { |
| 14202 | ConstPtrMut ptr_mut; | 14024 | ConstPtrMut ptr_mut; |
| 14203 | if (comptime_var_mem) { | 14025 | if (comptime_var_mem) { |
| ... | @@ -14478,7 +14300,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call | ... | @@ -14478,7 +14300,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call |
| 14478 | AstNode *body_node = fn_entry->body_node; | 14300 | AstNode *body_node = fn_entry->body_node; |
| 14479 | result = ir_eval_const_value(ira->codegen, exec_scope, body_node, return_type, | 14301 | result = ir_eval_const_value(ira->codegen, exec_scope, body_node, return_type, |
| 14480 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, fn_entry, | 14302 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, fn_entry, |
| 14481 | nullptr, call_instruction->base.source_node, nullptr, ira->new_irb.exec, return_type_node, false); | 14303 | nullptr, call_instruction->base.source_node, nullptr, ira->new_irb.exec, return_type_node); |
| 14482 | | 14304 | |
| 14483 | if (inferred_err_set_type != nullptr) { | 14305 | if (inferred_err_set_type != nullptr) { |
| 14484 | inferred_err_set_type->data.error_set.infer_fn = nullptr; | 14306 | inferred_err_set_type->data.error_set.infer_fn = nullptr; |
| ... | @@ -14674,8 +14496,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call | ... | @@ -14674,8 +14496,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call |
| 14674 | ConstExprValue *align_result = ir_eval_const_value(ira->codegen, impl_fn->child_scope, | 14496 | ConstExprValue *align_result = ir_eval_const_value(ira->codegen, impl_fn->child_scope, |
| 14675 | fn_proto_node->data.fn_proto.align_expr, get_align_amt_type(ira->codegen), | 14497 | fn_proto_node->data.fn_proto.align_expr, get_align_amt_type(ira->codegen), |
| 14676 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, | 14498 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, |
| 14677 | nullptr, nullptr, fn_proto_node->data.fn_proto.align_expr, nullptr, ira->new_irb.exec, nullptr, | 14499 | nullptr, nullptr, fn_proto_node->data.fn_proto.align_expr, nullptr, ira->new_irb.exec, nullptr); |
| 14678 | false); | | |
| 14679 | IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, | 14500 | IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb, |
| 14680 | impl_fn->child_scope, fn_proto_node->data.fn_proto.align_expr); | 14501 | impl_fn->child_scope, fn_proto_node->data.fn_proto.align_expr); |
| 14681 | const_instruction->base.value = *align_result; | 14502 | const_instruction->base.value = *align_result; |
| ... | @@ -15808,7 +15629,7 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira, | ... | @@ -15808,7 +15629,7 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira, |
| 15808 | auto entry = container_scope->decl_table.maybe_get(field_name); | 15629 | auto entry = container_scope->decl_table.maybe_get(field_name); |
| 15809 | Tld *tld = entry ? entry->value : nullptr; | 15630 | Tld *tld = entry ? entry->value : nullptr; |
| 15810 | if (tld && tld->id == TldIdFn) { | 15631 | if (tld && tld->id == TldIdFn) { |
| 15811 | resolve_top_level_decl(ira->codegen, tld, source_instr->source_node, false); | 15632 | resolve_top_level_decl(ira->codegen, tld, source_instr->source_node); |
| 15812 | if (tld->resolution == TldResolutionInvalid) | 15633 | if (tld->resolution == TldResolutionInvalid) |
| 15813 | return ira->codegen->invalid_instruction; | 15634 | return ira->codegen->invalid_instruction; |
| 15814 | TldFn *tld_fn = (TldFn *)tld; | 15635 | TldFn *tld_fn = (TldFn *)tld; |
| ... | @@ -15999,7 +15820,7 @@ static void add_link_lib_symbol(IrAnalyze *ira, Buf *lib_name, Buf *symbol_name, | ... | @@ -15999,7 +15820,7 @@ static void add_link_lib_symbol(IrAnalyze *ira, Buf *lib_name, Buf *symbol_name, |
| 15999 | | 15820 | |
| 16000 | | 15821 | |
| 16001 | static IrInstruction *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) { | 15822 | static IrInstruction *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) { |
| 16002 | resolve_top_level_decl(ira->codegen, tld, source_instruction->source_node, false); | 15823 | resolve_top_level_decl(ira->codegen, tld, source_instruction->source_node); |
| 16003 | if (tld->resolution == TldResolutionInvalid) | 15824 | if (tld->resolution == TldResolutionInvalid) |
| 16004 | return ira->codegen->invalid_instruction; | 15825 | return ira->codegen->invalid_instruction; |
| 16005 | | 15826 | |
| ... | @@ -16655,29 +16476,22 @@ static IrInstruction *ir_analyze_instruction_set_float_mode(IrAnalyze *ira, | ... | @@ -16655,29 +16476,22 @@ static IrInstruction *ir_analyze_instruction_set_float_mode(IrAnalyze *ira, |
| 16655 | static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, | 16476 | static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, |
| 16656 | IrInstructionSliceType *slice_type_instruction) | 16477 | IrInstructionSliceType *slice_type_instruction) |
| 16657 | { | 16478 | { |
| 16658 | IrInstruction *result = ir_const(ira, &slice_type_instruction->base, ira->codegen->builtin_types.entry_type); | 16479 | Error err; |
| 16659 | result->value.special = ConstValSpecialLazy; | 16480 | uint32_t align_bytes = 0; |
| 16660 | | | |
| 16661 | LazyValueSliceType *lazy_slice_type = allocate<LazyValueSliceType>(1); | | |
| 16662 | result->value.data.x_lazy = &lazy_slice_type->base; | | |
| 16663 | lazy_slice_type->base.id = LazyValueIdSliceType; | | |
| 16664 | lazy_slice_type->base.exec = ira->new_irb.exec; | | |
| 16665 | | | |
| 16666 | if (slice_type_instruction->align_value != nullptr) { | 16481 | if (slice_type_instruction->align_value != nullptr) { |
| 16667 | lazy_slice_type->align_val = ir_resolve_const(ira, slice_type_instruction->align_value->child, LazyOk); | 16482 | if (!ir_resolve_align(ira, slice_type_instruction->align_value->child, &align_bytes)) |
| 16668 | if (lazy_slice_type->align_val == nullptr) | | |
| 16669 | return ira->codegen->invalid_instruction; | 16483 | return ira->codegen->invalid_instruction; |
| 16670 | } | 16484 | } |
| 16671 | | 16485 | |
| 16672 | lazy_slice_type->elem_type = ir_resolve_type(ira, slice_type_instruction->child_type->child); | 16486 | ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->child); |
| 16673 | if (type_is_invalid(lazy_slice_type->elem_type)) | 16487 | if (type_is_invalid(child_type)) |
| 16674 | return ira->codegen->invalid_instruction; | 16488 | return ira->codegen->invalid_instruction; |
| 16675 | | 16489 | |
| 16676 | lazy_slice_type->is_const = slice_type_instruction->is_const; | 16490 | bool is_const = slice_type_instruction->is_const; |
| 16677 | lazy_slice_type->is_volatile = slice_type_instruction->is_volatile; | 16491 | bool is_volatile = slice_type_instruction->is_volatile; |
| 16678 | lazy_slice_type->is_allowzero = slice_type_instruction->is_allow_zero; | 16492 | bool is_allow_zero = slice_type_instruction->is_allow_zero; |
| 16679 | | 16493 | |
| 16680 | switch (lazy_slice_type->elem_type->id) { | 16494 | switch (child_type->id) { |
| 16681 | case ZigTypeIdInvalid: // handled above | 16495 | case ZigTypeIdInvalid: // handled above |
| 16682 | zig_unreachable(); | 16496 | zig_unreachable(); |
| 16683 | case ZigTypeIdUnreachable: | 16497 | case ZigTypeIdUnreachable: |
| ... | @@ -16686,7 +16500,7 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, | ... | @@ -16686,7 +16500,7 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, |
| 16686 | case ZigTypeIdArgTuple: | 16500 | case ZigTypeIdArgTuple: |
| 16687 | case ZigTypeIdOpaque: | 16501 | case ZigTypeIdOpaque: |
| 16688 | ir_add_error_node(ira, slice_type_instruction->base.source_node, | 16502 | ir_add_error_node(ira, slice_type_instruction->base.source_node, |
| 16689 | buf_sprintf("slice of type '%s' not allowed", buf_ptr(&lazy_slice_type->elem_type->name))); | 16503 | buf_sprintf("slice of type '%s' not allowed", buf_ptr(&child_type->name))); |
| 16690 | return ira->codegen->invalid_instruction; | 16504 | return ira->codegen->invalid_instruction; |
| 16691 | case ZigTypeIdMetaType: | 16505 | case ZigTypeIdMetaType: |
| 16692 | case ZigTypeIdVoid: | 16506 | case ZigTypeIdVoid: |
| ... | @@ -16708,7 +16522,14 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, | ... | @@ -16708,7 +16522,14 @@ static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira, |
| 16708 | case ZigTypeIdBoundFn: | 16522 | case ZigTypeIdBoundFn: |
| 16709 | case ZigTypeIdPromise: | 16523 | case ZigTypeIdPromise: |
| 16710 | case ZigTypeIdVector: | 16524 | case ZigTypeIdVector: |
| 16711 | return result; | 16525 | { |
| | 16526 | if ((err = type_resolve(ira->codegen, child_type, ResolveStatusZeroBitsKnown))) |
| | 16527 | return ira->codegen->invalid_instruction; |
| | 16528 | ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type, |
| | 16529 | is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0, is_allow_zero); |
| | 16530 | ZigType *result_type = get_slice_type(ira->codegen, slice_ptr_type); |
| | 16531 | return ir_const_type(ira, &slice_type_instruction->base, result_type); |
| | 16532 | } |
| 16712 | } | 16533 | } |
| 16713 | zig_unreachable(); | 16534 | zig_unreachable(); |
| 16714 | } | 16535 | } |
| ... | @@ -16815,7 +16636,7 @@ static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira, | ... | @@ -16815,7 +16636,7 @@ static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira, |
| 16815 | case ZigTypeIdPromise: | 16636 | case ZigTypeIdPromise: |
| 16816 | case ZigTypeIdVector: | 16637 | case ZigTypeIdVector: |
| 16817 | { | 16638 | { |
| 16818 | if ((err = type_resolve(ira->codegen, child_type, ResolveStatusSizeKnown))) | 16639 | if ((err = ensure_complete_type(ira->codegen, child_type))) |
| 16819 | return ira->codegen->invalid_instruction; | 16640 | return ira->codegen->invalid_instruction; |
| 16820 | ZigType *result_type = get_array_type(ira->codegen, child_type, size); | 16641 | ZigType *result_type = get_array_type(ira->codegen, child_type, size); |
| 16821 | return ir_const_type(ira, &array_type_instruction->base, result_type); | 16642 | return ir_const_type(ira, &array_type_instruction->base, result_type); |
| ... | @@ -18172,7 +17993,7 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, IrInstruction *source_instr, | ... | @@ -18172,7 +17993,7 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, IrInstruction *source_instr, |
| 18172 | while ((curr_entry = decl_it.next()) != nullptr) { | 17993 | while ((curr_entry = decl_it.next()) != nullptr) { |
| 18173 | // If the definition is unresolved, force it to be resolved again. | 17994 | // If the definition is unresolved, force it to be resolved again. |
| 18174 | if (curr_entry->value->resolution == TldResolutionUnresolved) { | 17995 | if (curr_entry->value->resolution == TldResolutionUnresolved) { |
| 18175 | resolve_top_level_decl(ira->codegen, curr_entry->value, curr_entry->value->source_node, false); | 17996 | resolve_top_level_decl(ira->codegen, curr_entry->value, curr_entry->value->source_node); |
| 18176 | if (curr_entry->value->resolution != TldResolutionOk) { | 17997 | if (curr_entry->value->resolution != TldResolutionOk) { |
| 18177 | return ErrorSemanticAnalyzeFail; | 17998 | return ErrorSemanticAnalyzeFail; |
| 18178 | } | 17999 | } |
| ... | @@ -19161,7 +18982,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct | ... | @@ -19161,7 +18982,7 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct |
| 19161 | ZigType *void_type = ira->codegen->builtin_types.entry_void; | 18982 | ZigType *void_type = ira->codegen->builtin_types.entry_void; |
| 19162 | ConstExprValue *cimport_result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type, | 18983 | ConstExprValue *cimport_result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type, |
| 19163 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr, | 18984 | ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr, |
| 19164 | &cimport_scope->buf, block_node, nullptr, nullptr, nullptr, false); | 18985 | &cimport_scope->buf, block_node, nullptr, nullptr, nullptr); |
| 19165 | if (type_is_invalid(cimport_result->type)) | 18986 | if (type_is_invalid(cimport_result->type)) |
| 19166 | return ira->codegen->invalid_instruction; | 18987 | return ira->codegen->invalid_instruction; |
| 19167 | | 18988 | |
| ... | @@ -20708,11 +20529,15 @@ static IrInstruction *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructio | ... | @@ -20708,11 +20529,15 @@ static IrInstruction *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructio |
| 20708 | } | 20529 | } |
| 20709 | | 20530 | |
| 20710 | static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) { | 20531 | static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) { |
| | 20532 | Error err; |
| 20711 | IrInstruction *type_value = instruction->type_value->child; | 20533 | IrInstruction *type_value = instruction->type_value->child; |
| 20712 | if (type_is_invalid(type_value->value.type)) | 20534 | if (type_is_invalid(type_value->value.type)) |
| 20713 | return ira->codegen->invalid_instruction; | 20535 | return ira->codegen->invalid_instruction; |
| 20714 | ZigType *type_entry = ir_resolve_type(ira, type_value); | 20536 | ZigType *type_entry = ir_resolve_type(ira, type_value); |
| 20715 | | 20537 | |
| | 20538 | if ((err = type_resolve(ira->codegen, type_entry, ResolveStatusAlignmentKnown))) |
| | 20539 | return ira->codegen->invalid_instruction; |
| | 20540 | |
| 20716 | switch (type_entry->id) { | 20541 | switch (type_entry->id) { |
| 20717 | case ZigTypeIdInvalid: | 20542 | case ZigTypeIdInvalid: |
| 20718 | zig_unreachable(); | 20543 | zig_unreachable(); |
| ... | @@ -20744,25 +20569,12 @@ static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstruct | ... | @@ -20744,25 +20569,12 @@ static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstruct |
| 20744 | case ZigTypeIdUnion: | 20569 | case ZigTypeIdUnion: |
| 20745 | case ZigTypeIdFn: | 20570 | case ZigTypeIdFn: |
| 20746 | case ZigTypeIdVector: | 20571 | case ZigTypeIdVector: |
| 20747 | break; | 20572 | { |
| | 20573 | uint64_t align_in_bytes = get_abi_alignment(ira->codegen, type_entry); |
| | 20574 | return ir_const_unsigned(ira, &instruction->base, align_in_bytes); |
| | 20575 | } |
| 20748 | } | 20576 | } |
| 20749 | if (type_is_resolved(type_entry, ResolveStatusAlignmentKnown)) { | 20577 | zig_unreachable(); |
| 20750 | uint64_t align_in_bytes = get_abi_alignment(ira->codegen, type_entry); | | |
| 20751 | return ir_const_unsigned(ira, &instruction->base, align_in_bytes); | | |
| 20752 | } | | |
| 20753 | // Here we create a lazy value in order to avoid resolving the alignment of the type | | |
| 20754 | // immediately. This avoids false positive dependency loops such as: | | |
| 20755 | // const Node = struct { | | |
| 20756 | // field: []align(@alignOf(Node)) Node, | | |
| 20757 | // }; | | |
| 20758 | LazyValueAlignOf *lazy_align_of = allocate<LazyValueAlignOf>(1); | | |
| 20759 | lazy_align_of->base.id = LazyValueIdAlignOf; | | |
| 20760 | lazy_align_of->base.exec = ira->new_irb.exec; | | |
| 20761 | lazy_align_of->target_type = type_entry; | | |
| 20762 | IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int); | | |
| 20763 | result->value.special = ConstValSpecialLazy; | | |
| 20764 | result->value.data.x_lazy = &lazy_align_of->base; | | |
| 20765 | return result; | | |
| 20766 | } | 20578 | } |
| 20767 | | 20579 | |
| 20768 | static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) { | 20580 | static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) { |
| ... | @@ -21017,77 +20829,96 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct | ... | @@ -21017,77 +20829,96 @@ static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstruct |
| 21017 | AstNode *proto_node = instruction->base.source_node; | 20829 | AstNode *proto_node = instruction->base.source_node; |
| 21018 | assert(proto_node->type == NodeTypeFnProto); | 20830 | assert(proto_node->type == NodeTypeFnProto); |
| 21019 | | 20831 | |
| 21020 | IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_type); | | |
| 21021 | result->value.special = ConstValSpecialLazy; | | |
| 21022 | | | |
| 21023 | LazyValueFnType *lazy_fn_type = allocate<LazyValueFnType>(1); | | |
| 21024 | result->value.data.x_lazy = &lazy_fn_type->base; | | |
| 21025 | lazy_fn_type->base.id = LazyValueIdFnType; | | |
| 21026 | lazy_fn_type->base.exec = ira->new_irb.exec; | | |
| 21027 | | | |
| 21028 | if (proto_node->data.fn_proto.auto_err_set) { | 20832 | if (proto_node->data.fn_proto.auto_err_set) { |
| 21029 | ir_add_error(ira, &instruction->base, | 20833 | ir_add_error(ira, &instruction->base, |
| 21030 | buf_sprintf("inferring error set of return type valid only for function definitions")); | 20834 | buf_sprintf("inferring error set of return type valid only for function definitions")); |
| 21031 | return ira->codegen->invalid_instruction; | 20835 | return ira->codegen->invalid_instruction; |
| 21032 | } | 20836 | } |
| 21033 | | 20837 | |
| 21034 | size_t param_count = proto_node->data.fn_proto.params.length; | 20838 | FnTypeId fn_type_id = {0}; |
| 21035 | lazy_fn_type->proto_node = proto_node; | 20839 | init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length); |
| 21036 | lazy_fn_type->param_types = allocate<ConstExprValue *>(param_count); | | |
| 21037 | | 20840 | |
| 21038 | for (size_t i = 0; i < param_count; i += 1) { | 20841 | for (; fn_type_id.next_param_index < fn_type_id.param_count; fn_type_id.next_param_index += 1) { |
| 21039 | AstNode *param_node = proto_node->data.fn_proto.params.at(i); | 20842 | AstNode *param_node = proto_node->data.fn_proto.params.at(fn_type_id.next_param_index); |
| 21040 | assert(param_node->type == NodeTypeParamDecl); | 20843 | assert(param_node->type == NodeTypeParamDecl); |
| 21041 | | 20844 | |
| 21042 | bool param_is_var_args = param_node->data.param_decl.is_var_args; | 20845 | bool param_is_var_args = param_node->data.param_decl.is_var_args; |
| 21043 | lazy_fn_type->is_var_args = true; | | |
| 21044 | if (param_is_var_args) { | 20846 | if (param_is_var_args) { |
| 21045 | if (proto_node->data.fn_proto.cc == CallingConventionC) { | 20847 | if (fn_type_id.cc == CallingConventionC) { |
| 21046 | break; | 20848 | fn_type_id.param_count = fn_type_id.next_param_index; |
| 21047 | } else if (proto_node->data.fn_proto.cc == CallingConventionUnspecified) { | 20849 | continue; |
| 21048 | lazy_fn_type->is_generic = true; | 20850 | } else if (fn_type_id.cc == CallingConventionUnspecified) { |
| 21049 | return result; | 20851 | return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id)); |
| 21050 | } else { | 20852 | } else { |
| 21051 | zig_unreachable(); | 20853 | zig_unreachable(); |
| 21052 | } | 20854 | } |
| 21053 | } | 20855 | } |
| | 20856 | FnTypeParamInfo *param_info = &fn_type_id.param_info[fn_type_id.next_param_index]; |
| | 20857 | param_info->is_noalias = param_node->data.param_decl.is_noalias; |
| 21054 | | 20858 | |
| 21055 | if (instruction->param_types[i] == nullptr) { | 20859 | if (instruction->param_types[fn_type_id.next_param_index] == nullptr) { |
| 21056 | lazy_fn_type->is_generic = true; | 20860 | param_info->type = nullptr; |
| 21057 | return result; | 20861 | return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id)); |
| | 20862 | } else { |
| | 20863 | IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->child; |
| | 20864 | if (type_is_invalid(param_type_value->value.type)) |
| | 20865 | return ira->codegen->invalid_instruction; |
| | 20866 | ZigType *param_type = ir_resolve_type(ira, param_type_value); |
| | 20867 | switch (type_requires_comptime(ira->codegen, param_type)) { |
| | 20868 | case ReqCompTimeYes: |
| | 20869 | if (!calling_convention_allows_zig_types(fn_type_id.cc)) { |
| | 20870 | ir_add_error(ira, param_type_value, |
| | 20871 | buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'", |
| | 20872 | buf_ptr(¶m_type->name), calling_convention_name(fn_type_id.cc))); |
| | 20873 | return ira->codegen->invalid_instruction; |
| | 20874 | } |
| | 20875 | param_info->type = param_type; |
| | 20876 | fn_type_id.next_param_index += 1; |
| | 20877 | return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id)); |
| | 20878 | case ReqCompTimeInvalid: |
| | 20879 | return ira->codegen->invalid_instruction; |
| | 20880 | case ReqCompTimeNo: |
| | 20881 | break; |
| | 20882 | } |
| | 20883 | if (!type_has_bits(param_type) && !calling_convention_allows_zig_types(fn_type_id.cc)) { |
| | 20884 | ir_add_error(ira, param_type_value, |
| | 20885 | buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'", |
| | 20886 | buf_ptr(¶m_type->name), calling_convention_name(fn_type_id.cc))); |
| | 20887 | return ira->codegen->invalid_instruction; |
| | 20888 | } |
| | 20889 | param_info->type = param_type; |
| 21058 | } | 20890 | } |
| 21059 | | 20891 | |
| 21060 | IrInstruction *param_type_value = instruction->param_types[i]->child; | | |
| 21061 | if (type_is_invalid(param_type_value->value.type)) | | |
| 21062 | return ira->codegen->invalid_instruction; | | |
| 21063 | ConstExprValue *param_type_val = ir_resolve_const(ira, param_type_value, LazyOk); | | |
| 21064 | if (param_type_val == nullptr) | | |
| 21065 | return ira->codegen->invalid_instruction; | | |
| 21066 | lazy_fn_type->param_types[i] = param_type_val; | | |
| 21067 | } | 20892 | } |
| 21068 | | 20893 | |
| 21069 | if (instruction->align_value != nullptr) { | 20894 | if (instruction->align_value != nullptr) { |
| 21070 | lazy_fn_type->align_val = ir_resolve_const(ira, instruction->align_value->child, LazyOk); | 20895 | if (!ir_resolve_align(ira, instruction->align_value->child, &fn_type_id.alignment)) |
| 21071 | if (lazy_fn_type->align_val == nullptr) | | |
| 21072 | return ira->codegen->invalid_instruction; | 20896 | return ira->codegen->invalid_instruction; |
| 21073 | } | 20897 | } |
| 21074 | | 20898 | |
| 21075 | lazy_fn_type->return_type = ir_resolve_const(ira, instruction->return_type->child, LazyOk); | 20899 | IrInstruction *return_type_value = instruction->return_type->child; |
| 21076 | if (lazy_fn_type->return_type == nullptr) | 20900 | fn_type_id.return_type = ir_resolve_type(ira, return_type_value); |
| | 20901 | if (type_is_invalid(fn_type_id.return_type)) |
| 21077 | return ira->codegen->invalid_instruction; | 20902 | return ira->codegen->invalid_instruction; |
| | 20903 | if (fn_type_id.return_type->id == ZigTypeIdOpaque) { |
| | 20904 | ir_add_error(ira, instruction->return_type, |
| | 20905 | buf_sprintf("return type cannot be opaque")); |
| | 20906 | return ira->codegen->invalid_instruction; |
| | 20907 | } |
| 21078 | | 20908 | |
| 21079 | if (proto_node->data.fn_proto.cc == CallingConventionAsync) { | 20909 | if (fn_type_id.cc == CallingConventionAsync) { |
| 21080 | if (instruction->async_allocator_type_value == nullptr) { | 20910 | if (instruction->async_allocator_type_value == nullptr) { |
| 21081 | ir_add_error(ira, &instruction->base, | 20911 | ir_add_error(ira, &instruction->base, |
| 21082 | buf_sprintf("async fn proto missing allocator type")); | 20912 | buf_sprintf("async fn proto missing allocator type")); |
| 21083 | return ira->codegen->invalid_instruction; | 20913 | return ira->codegen->invalid_instruction; |
| 21084 | } | 20914 | } |
| 21085 | lazy_fn_type->async_allocator_type = ir_resolve_const(ira, instruction->async_allocator_type_value->child, LazyOk); | 20915 | IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->child; |
| 21086 | if (lazy_fn_type->async_allocator_type == nullptr) | 20916 | fn_type_id.async_allocator_type = ir_resolve_type(ira, async_allocator_type_value); |
| | 20917 | if (type_is_invalid(fn_type_id.async_allocator_type)) |
| 21087 | return ira->codegen->invalid_instruction; | 20918 | return ira->codegen->invalid_instruction; |
| 21088 | } | 20919 | } |
| 21089 | | 20920 | |
| 21090 | return result; | 20921 | return ir_const_type(ira, &instruction->base, get_fn_type(ira->codegen, &fn_type_id)); |
| 21091 | } | 20922 | } |
| 21092 | | 20923 | |
| 21093 | static IrInstruction *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) { | 20924 | static IrInstruction *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) { |
| ... | @@ -21756,11 +21587,8 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou | ... | @@ -21756,11 +21587,8 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou |
| 21756 | val->type->data.vector.len); | 21587 | val->type->data.vector.len); |
| 21757 | case ZigTypeIdEnum: | 21588 | case ZigTypeIdEnum: |
| 21758 | switch (val->type->data.enumeration.layout) { | 21589 | switch (val->type->data.enumeration.layout) { |
| 21759 | case ContainerLayoutAuto: { | 21590 | case ContainerLayoutAuto: |
| 21760 | opt_ir_add_error_node(ira, codegen, source_node, | 21591 | zig_panic("TODO buf_read_value_bytes enum auto"); |
| 21761 | buf_sprintf("compiler bug: TODO: implement enum byte reinterpretation")); | | |
| 21762 | return ErrorSemanticAnalyzeFail; | | |
| 21763 | } | | |
| 21764 | case ContainerLayoutPacked: | 21592 | case ContainerLayoutPacked: |
| 21765 | zig_panic("TODO buf_read_value_bytes enum packed"); | 21593 | zig_panic("TODO buf_read_value_bytes enum packed"); |
| 21766 | case ContainerLayoutExtern: { | 21594 | case ContainerLayoutExtern: { |
| ... | @@ -22056,7 +21884,7 @@ static IrInstruction *ir_analyze_instruction_decl_ref(IrAnalyze *ira, | ... | @@ -22056,7 +21884,7 @@ static IrInstruction *ir_analyze_instruction_decl_ref(IrAnalyze *ira, |
| 22056 | Tld *tld = instruction->tld; | 21884 | Tld *tld = instruction->tld; |
| 22057 | LVal lval = instruction->lval; | 21885 | LVal lval = instruction->lval; |
| 22058 | | 21886 | |
| 22059 | resolve_top_level_decl(ira->codegen, tld, instruction->base.source_node, true); | 21887 | resolve_top_level_decl(ira->codegen, tld, instruction->base.source_node); |
| 22060 | if (tld->resolution == TldResolutionInvalid) | 21888 | if (tld->resolution == TldResolutionInvalid) |
| 22061 | return ira->codegen->invalid_instruction; | 21889 | return ira->codegen->invalid_instruction; |
| 22062 | | 21890 | |
Andrew Kelley <andrew@ziglang.org> 2019-04-01 17:46:31-04:00
Commit is signed but in an unrecognized format.