authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-10-04 14:32:55-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-10-04 14:33:52-04:00
log23b07ad8d25809baa3169f64d9c7be980501352d
treec2ccfa4832e4c2ac5517b937487fb378a3265ace
parent31469daca397b7cdb8c348932a7a3c9e27354fa5
signature Commit is signed but in an unrecognized format.

refactor ir.cpp

Analysis functions no longer return `ZigType *`. Instead they return `IrInstruction *`.

4 files changed, 1716 insertions(+), 2124 deletions(-)

src/all_types.hpp+5-1
......@@ -1690,6 +1690,7 @@ struct CodeGen {
16901690 Buf cache_dir;
16911691
16921692 IrInstruction *invalid_instruction;
1693 IrInstruction *unreach_instruction;
16931694
16941695 ConstExprValue const_void_val;
16951696 ConstExprValue panic_msg_vals[PanicMsgIdCount];
......@@ -2183,7 +2184,10 @@ struct IrInstruction {
21832184 // if ref_count is zero and the instruction has no side effects,
21842185 // the instruction can be omitted in codegen
21852186 size_t ref_count;
2186 IrInstruction *other;
2187 // When analyzing IR, instructions that point to this instruction in the "old ir"
2188 // can find the instruction that corresponds to this value in the "new ir"
2189 // with this child field.
2190 IrInstruction *child;
21872191 IrBasicBlock *owner_bb;
21882192 // true if this instruction was generated by zig and not from user code
21892193 bool is_gen;
src/analyze.cpp+12-3
......@@ -5512,10 +5512,19 @@ Error type_resolve(CodeGen *g, ZigType *ty, ResolveStatus status) {
55125512}
55135513
55145514bool ir_get_var_is_comptime(ZigVar *var) {
5515 if (!var->is_comptime)
5515 // The is_comptime field can be left null, which means not comptime.
5516 if (var->is_comptime == nullptr)
55165517 return false;
5517 if (var->is_comptime->other)
5518 return var->is_comptime->other->value.data.x_bool;
5518 // When the is_comptime field references an instruction that has to get analyzed, this
5519 // is the value.
5520 if (var->is_comptime->child != nullptr) {
5521 assert(var->is_comptime->child->value.type->id == ZigTypeIdBool);
5522 return var->is_comptime->child->value.data.x_bool;
5523 }
5524 // As an optimization, is_comptime values which are constant are allowed
5525 // to be omitted from analysis. In this case, there is no child instruction
5526 // and we simply look at the unanalyzed const parent instruction.
5527 assert(var->is_comptime->value.type->id == ZigTypeIdBool);
55195528 return var->is_comptime->value.data.x_bool;
55205529}
55215530
src/codegen.cpp+6-1
......@@ -7279,10 +7279,15 @@ static void init(CodeGen *g) {
72797279
72807280 define_builtin_types(g);
72817281
7282 g->invalid_instruction = allocate<IrInstruction>(1);
7282 IrInstruction *sentinel_instructions = allocate<IrInstruction>(2);
7283 g->invalid_instruction = &sentinel_instructions[0];
72837284 g->invalid_instruction->value.type = g->builtin_types.entry_invalid;
72847285 g->invalid_instruction->value.global_refs = allocate<ConstGlobalRefs>(1);
72857286
7287 g->unreach_instruction = &sentinel_instructions[1];
7288 g->unreach_instruction->value.type = g->builtin_types.entry_unreachable;
7289 g->unreach_instruction->value.global_refs = allocate<ConstGlobalRefs>(1);
7290
72867291 g->const_void_val.special = ConstValSpecialStatic;
72877292 g->const_void_val.type = g->builtin_types.entry_void;
72887293 g->const_void_val.global_refs = allocate<ConstGlobalRefs>(1);
src/ir.cpp+1693-2119
......@@ -140,7 +140,7 @@ struct ConstCastErrSetMismatch {
140140
141141static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope);
142142static IrInstruction *ir_gen_node_extra(IrBuilder *irb, AstNode *node, Scope *scope, LVal lval);
143static ZigType *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction);
143static IrInstruction *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction);
144144static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type);
145145static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr);
146146static ErrorMsg *exec_add_error_node(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, Buf *msg);
......@@ -261,11 +261,6 @@ static bool instr_is_unreachable(IrInstruction *instruction) {
261261 return instruction->value.type && instruction->value.type->id == ZigTypeIdUnreachable;
262262}
263263
264static void ir_link_new_instruction(IrInstruction *new_instruction, IrInstruction *old_instruction) {
265 new_instruction->other = old_instruction;
266 old_instruction->other = new_instruction;
267}
268
269264static void ir_link_new_bb(IrBasicBlock *new_bb, IrBasicBlock *old_bb) {
270265 new_bb->other = old_bb;
271266 old_bb->other = new_bb;
......@@ -919,15 +914,6 @@ static IrInstruction *ir_build_cond_br(IrBuilder *irb, Scope *scope, AstNode *so
919914 return &cond_br_instruction->base;
920915}
921916
922static IrInstruction *ir_build_cond_br_from(IrBuilder *irb, IrInstruction *old_instruction,
923 IrInstruction *condition, IrBasicBlock *then_block, IrBasicBlock *else_block, IrInstruction *is_comptime)
924{
925 IrInstruction *new_instruction = ir_build_cond_br(irb, old_instruction->scope, old_instruction->source_node,
926 condition, then_block, else_block, is_comptime);
927 ir_link_new_instruction(new_instruction, old_instruction);
928 return new_instruction;
929}
930
931917static IrInstruction *ir_build_return(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *return_value) {
932918 IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, scope, source_node);
933919 return_instruction->base.value.type = irb->codegen->builtin_types.entry_unreachable;
......@@ -1098,15 +1084,6 @@ static IrInstruction *ir_build_bin_op(IrBuilder *irb, Scope *scope, AstNode *sou
10981084 return &bin_op_instruction->base;
10991085}
11001086
1101static IrInstruction *ir_build_bin_op_from(IrBuilder *irb, IrInstruction *old_instruction, IrBinOp op_id,
1102 IrInstruction *op1, IrInstruction *op2, bool safety_check_on)
1103{
1104 IrInstruction *new_instruction = ir_build_bin_op(irb, old_instruction->scope,
1105 old_instruction->source_node, op_id, op1, op2, safety_check_on);
1106 ir_link_new_instruction(new_instruction, old_instruction);
1107 return new_instruction;
1108}
1109
11101087static IrInstruction *ir_build_var_ptr_x(IrBuilder *irb, Scope *scope, AstNode *source_node, ZigVar *var,
11111088 ScopeFnDef *crossed_fndef_scope)
11121089{
......@@ -1189,15 +1166,6 @@ static IrInstruction *ir_build_union_field_ptr(IrBuilder *irb, Scope *scope, Ast
11891166 return &instruction->base;
11901167}
11911168
1192static IrInstruction *ir_build_union_field_ptr_from(IrBuilder *irb, IrInstruction *old_instruction,
1193 IrInstruction *union_ptr, TypeUnionField *type_union_field)
1194{
1195 IrInstruction *new_instruction = ir_build_union_field_ptr(irb, old_instruction->scope,
1196 old_instruction->source_node, union_ptr, type_union_field);
1197 ir_link_new_instruction(new_instruction, old_instruction);
1198 return new_instruction;
1199}
1200
12011169static IrInstruction *ir_build_call(IrBuilder *irb, Scope *scope, AstNode *source_node,
12021170 ZigFn *fn_entry, IrInstruction *fn_ref, size_t arg_count, IrInstruction **args,
12031171 bool is_comptime, FnInline fn_inline, bool is_async, IrInstruction *async_allocator,
......@@ -1226,17 +1194,6 @@ static IrInstruction *ir_build_call(IrBuilder *irb, Scope *scope, AstNode *sourc
12261194 return &call_instruction->base;
12271195}
12281196
1229static IrInstruction *ir_build_call_from(IrBuilder *irb, IrInstruction *old_instruction,
1230 ZigFn *fn_entry, IrInstruction *fn_ref, size_t arg_count, IrInstruction **args,
1231 bool is_comptime, FnInline fn_inline, bool is_async, IrInstruction *async_allocator,
1232 IrInstruction *new_stack)
1233{
1234 IrInstruction *new_instruction = ir_build_call(irb, old_instruction->scope,
1235 old_instruction->source_node, fn_entry, fn_ref, arg_count, args, is_comptime, fn_inline, is_async, async_allocator, new_stack);
1236 ir_link_new_instruction(new_instruction, old_instruction);
1237 return new_instruction;
1238}
1239
12401197static IrInstruction *ir_build_phi(IrBuilder *irb, Scope *scope, AstNode *source_node,
12411198 size_t incoming_count, IrBasicBlock **incoming_blocks, IrInstruction **incoming_values)
12421199{
......@@ -1256,15 +1213,6 @@ static IrInstruction *ir_build_phi(IrBuilder *irb, Scope *scope, AstNode *source
12561213 return &phi_instruction->base;
12571214}
12581215
1259static IrInstruction *ir_build_phi_from(IrBuilder *irb, IrInstruction *old_instruction,
1260 size_t incoming_count, IrBasicBlock **incoming_blocks, IrInstruction **incoming_values)
1261{
1262 IrInstruction *new_instruction = ir_build_phi(irb, old_instruction->scope, old_instruction->source_node,
1263 incoming_count, incoming_blocks, incoming_values);
1264 ir_link_new_instruction(new_instruction, old_instruction);
1265 return new_instruction;
1266}
1267
12681216static IrInstruction *ir_create_br(IrBuilder *irb, Scope *scope, AstNode *source_node,
12691217 IrBasicBlock *dest_block, IrInstruction *is_comptime)
12701218{
......@@ -1288,12 +1236,6 @@ static IrInstruction *ir_build_br(IrBuilder *irb, Scope *scope, AstNode *source_
12881236 return instruction;
12891237}
12901238
1291static IrInstruction *ir_build_br_from(IrBuilder *irb, IrInstruction *old_instruction, IrBasicBlock *dest_block) {
1292 IrInstruction *new_instruction = ir_build_br(irb, old_instruction->scope, old_instruction->source_node, dest_block, nullptr);
1293 ir_link_new_instruction(new_instruction, old_instruction);
1294 return new_instruction;
1295}
1296
12971239static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
12981240 IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
12991241 IrInstruction *align_value, uint32_t bit_offset_start, uint32_t host_int_bytes)
......@@ -1323,15 +1265,6 @@ static IrInstruction *ir_build_un_op(IrBuilder *irb, Scope *scope, AstNode *sour
13231265 return &br_instruction->base;
13241266}
13251267
1326static IrInstruction *ir_build_un_op_from(IrBuilder *irb, IrInstruction *old_instruction,
1327 IrUnOp op_id, IrInstruction *value)
1328{
1329 IrInstruction *new_instruction = ir_build_un_op(irb, old_instruction->scope,
1330 old_instruction->source_node, op_id, value);
1331 ir_link_new_instruction(new_instruction, old_instruction);
1332 return new_instruction;
1333}
1334
13351268static IrInstruction *ir_build_container_init_list(IrBuilder *irb, Scope *scope, AstNode *source_node,
13361269 IrInstruction *container_type, size_t item_count, IrInstruction **items)
13371270{
......@@ -1349,15 +1282,6 @@ static IrInstruction *ir_build_container_init_list(IrBuilder *irb, Scope *scope,
13491282 return &container_init_list_instruction->base;
13501283}
13511284
1352static IrInstruction *ir_build_container_init_list_from(IrBuilder *irb, IrInstruction *old_instruction,
1353 IrInstruction *container_type, size_t item_count, IrInstruction **items)
1354{
1355 IrInstruction *new_instruction = ir_build_container_init_list(irb, old_instruction->scope,
1356 old_instruction->source_node, container_type, item_count, items);
1357 ir_link_new_instruction(new_instruction, old_instruction);
1358 return new_instruction;
1359}
1360
13611285static IrInstruction *ir_build_container_init_fields(IrBuilder *irb, Scope *scope, AstNode *source_node,
13621286 IrInstruction *container_type, size_t field_count, IrInstructionContainerInitFieldsField *fields)
13631287{
......@@ -1389,15 +1313,6 @@ static IrInstruction *ir_build_struct_init(IrBuilder *irb, Scope *scope, AstNode
13891313 return &struct_init_instruction->base;
13901314}
13911315
1392static IrInstruction *ir_build_struct_init_from(IrBuilder *irb, IrInstruction *old_instruction,
1393 ZigType *struct_type, size_t field_count, IrInstructionStructInitField *fields)
1394{
1395 IrInstruction *new_instruction = ir_build_struct_init(irb, old_instruction->scope,
1396 old_instruction->source_node, struct_type, field_count, fields);
1397 ir_link_new_instruction(new_instruction, old_instruction);
1398 return new_instruction;
1399}
1400
14011316static IrInstruction *ir_build_union_init(IrBuilder *irb, Scope *scope, AstNode *source_node,
14021317 ZigType *union_type, TypeUnionField *field, IrInstruction *init_value)
14031318{
......@@ -1411,15 +1326,6 @@ static IrInstruction *ir_build_union_init(IrBuilder *irb, Scope *scope, AstNode
14111326 return &union_init_instruction->base;
14121327}
14131328
1414static IrInstruction *ir_build_union_init_from(IrBuilder *irb, IrInstruction *old_instruction,
1415 ZigType *union_type, TypeUnionField *field, IrInstruction *init_value)
1416{
1417 IrInstruction *new_instruction = ir_build_union_init(irb, old_instruction->scope,
1418 old_instruction->source_node, union_type, field, init_value);
1419 ir_link_new_instruction(new_instruction, old_instruction);
1420 return new_instruction;
1421}
1422
14231329static IrInstruction *ir_build_unreachable(IrBuilder *irb, Scope *scope, AstNode *source_node) {
14241330 IrInstructionUnreachable *unreachable_instruction =
14251331 ir_build_instruction<IrInstructionUnreachable>(irb, scope, source_node);
......@@ -1428,12 +1334,6 @@ static IrInstruction *ir_build_unreachable(IrBuilder *irb, Scope *scope, AstNode
14281334 return &unreachable_instruction->base;
14291335}
14301336
1431static IrInstruction *ir_build_unreachable_from(IrBuilder *irb, IrInstruction *old_instruction) {
1432 IrInstruction *new_instruction = ir_build_unreachable(irb, old_instruction->scope, old_instruction->source_node);
1433 ir_link_new_instruction(new_instruction, old_instruction);
1434 return new_instruction;
1435}
1436
14371337static IrInstruction *ir_build_store_ptr(IrBuilder *irb, Scope *scope, AstNode *source_node,
14381338 IrInstruction *ptr, IrInstruction *value)
14391339{
......@@ -1449,15 +1349,6 @@ static IrInstruction *ir_build_store_ptr(IrBuilder *irb, Scope *scope, AstNode *
14491349 return &instruction->base;
14501350}
14511351
1452static IrInstruction *ir_build_store_ptr_from(IrBuilder *irb, IrInstruction *old_instruction,
1453 IrInstruction *ptr, IrInstruction *value)
1454{
1455 IrInstruction *new_instruction = ir_build_store_ptr(irb, old_instruction->scope,
1456 old_instruction->source_node, ptr, value);
1457 ir_link_new_instruction(new_instruction, old_instruction);
1458 return new_instruction;
1459}
1460
14611352static IrInstruction *ir_build_var_decl(IrBuilder *irb, Scope *scope, AstNode *source_node,
14621353 ZigVar *var, IrInstruction *var_type, IrInstruction *align_value, IrInstruction *init_value)
14631354{
......@@ -1476,15 +1367,6 @@ static IrInstruction *ir_build_var_decl(IrBuilder *irb, Scope *scope, AstNode *s
14761367 return &decl_var_instruction->base;
14771368}
14781369
1479static IrInstruction *ir_build_var_decl_from(IrBuilder *irb, IrInstruction *old_instruction,
1480 ZigVar *var, IrInstruction *var_type, IrInstruction *align_value, IrInstruction *init_value)
1481{
1482 IrInstruction *new_instruction = ir_build_var_decl(irb, old_instruction->scope,
1483 old_instruction->source_node, var, var_type, align_value, init_value);
1484 ir_link_new_instruction(new_instruction, old_instruction);
1485 return new_instruction;
1486}
1487
14881370static IrInstruction *ir_build_export(IrBuilder *irb, Scope *scope, AstNode *source_node,
14891371 IrInstruction *name, IrInstruction *target, IrInstruction *linkage)
14901372{
......@@ -1512,13 +1394,6 @@ static IrInstruction *ir_build_load_ptr(IrBuilder *irb, Scope *scope, AstNode *s
15121394 return &instruction->base;
15131395}
15141396
1515static IrInstruction *ir_build_load_ptr_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *ptr) {
1516 IrInstruction *new_instruction = ir_build_load_ptr(irb, old_instruction->scope,
1517 old_instruction->source_node, ptr);
1518 ir_link_new_instruction(new_instruction, old_instruction);
1519 return new_instruction;
1520}
1521
15221397static IrInstruction *ir_build_typeof(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
15231398 IrInstructionTypeOf *instruction = ir_build_instruction<IrInstructionTypeOf>(irb, scope, source_node);
15241399 instruction->value = value;
......@@ -1643,15 +1518,6 @@ static IrInstruction *ir_build_asm(IrBuilder *irb, Scope *scope, AstNode *source
16431518 return &instruction->base;
16441519}
16451520
1646static IrInstruction *ir_build_asm_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction **input_list,
1647 IrInstruction **output_types, ZigVar **output_vars, size_t return_count, bool has_side_effects)
1648{
1649 IrInstruction *new_instruction = ir_build_asm(irb, old_instruction->scope,
1650 old_instruction->source_node, input_list, output_types, output_vars, return_count, has_side_effects);
1651 ir_link_new_instruction(new_instruction, old_instruction);
1652 return new_instruction;
1653}
1654
16551521static IrInstruction *ir_build_size_of(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value) {
16561522 IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, scope, source_node);
16571523 instruction->type_value = type_value;
......@@ -1670,15 +1536,6 @@ static IrInstruction *ir_build_test_nonnull(IrBuilder *irb, Scope *scope, AstNod
16701536 return &instruction->base;
16711537}
16721538
1673static IrInstruction *ir_build_test_nonnull_from(IrBuilder *irb, IrInstruction *old_instruction,
1674 IrInstruction *value)
1675{
1676 IrInstruction *new_instruction = ir_build_test_nonnull(irb, old_instruction->scope,
1677 old_instruction->source_node, value);
1678 ir_link_new_instruction(new_instruction, old_instruction);
1679 return new_instruction;
1680}
1681
16821539static IrInstruction *ir_build_unwrap_maybe(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value,
16831540 bool safety_check_on)
16841541{
......@@ -1691,15 +1548,6 @@ static IrInstruction *ir_build_unwrap_maybe(IrBuilder *irb, Scope *scope, AstNod
16911548 return &instruction->base;
16921549}
16931550
1694static IrInstruction *ir_build_unwrap_maybe_from(IrBuilder *irb, IrInstruction *old_instruction,
1695 IrInstruction *value, bool safety_check_on)
1696{
1697 IrInstruction *new_instruction = ir_build_unwrap_maybe(irb, old_instruction->scope, old_instruction->source_node,
1698 value, safety_check_on);
1699 ir_link_new_instruction(new_instruction, old_instruction);
1700 return new_instruction;
1701}
1702
17031551static IrInstruction *ir_build_maybe_wrap(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
17041552 IrInstructionOptionalWrap *instruction = ir_build_instruction<IrInstructionOptionalWrap>(irb, scope, source_node);
17051553 instruction->value = value;
......@@ -1736,12 +1584,6 @@ static IrInstruction *ir_build_clz(IrBuilder *irb, Scope *scope, AstNode *source
17361584 return &instruction->base;
17371585}
17381586
1739static IrInstruction *ir_build_clz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
1740 IrInstruction *new_instruction = ir_build_clz(irb, old_instruction->scope, old_instruction->source_node, value);
1741 ir_link_new_instruction(new_instruction, old_instruction);
1742 return new_instruction;
1743}
1744
17451587static IrInstruction *ir_build_ctz(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
17461588 IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, scope, source_node);
17471589 instruction->value = value;
......@@ -1751,12 +1593,6 @@ static IrInstruction *ir_build_ctz(IrBuilder *irb, Scope *scope, AstNode *source
17511593 return &instruction->base;
17521594}
17531595
1754static IrInstruction *ir_build_ctz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
1755 IrInstruction *new_instruction = ir_build_ctz(irb, old_instruction->scope, old_instruction->source_node, value);
1756 ir_link_new_instruction(new_instruction, old_instruction);
1757 return new_instruction;
1758}
1759
17601596static IrInstruction *ir_build_pop_count(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
17611597 IrInstructionPopCount *instruction = ir_build_instruction<IrInstructionPopCount>(irb, scope, source_node);
17621598 instruction->value = value;
......@@ -1793,16 +1629,6 @@ static IrInstruction *ir_build_switch_br(IrBuilder *irb, Scope *scope, AstNode *
17931629 return &instruction->base;
17941630}
17951631
1796static IrInstruction *ir_build_switch_br_from(IrBuilder *irb, IrInstruction *old_instruction,
1797 IrInstruction *target_value, IrBasicBlock *else_block, size_t case_count,
1798 IrInstructionSwitchBrCase *cases, IrInstruction *is_comptime, IrInstruction *switch_prongs_void)
1799{
1800 IrInstruction *new_instruction = ir_build_switch_br(irb, old_instruction->scope, old_instruction->source_node,
1801 target_value, else_block, case_count, cases, is_comptime, switch_prongs_void);
1802 ir_link_new_instruction(new_instruction, old_instruction);
1803 return new_instruction;
1804}
1805
18061632static IrInstruction *ir_build_switch_target(IrBuilder *irb, Scope *scope, AstNode *source_node,
18071633 IrInstruction *target_value_ptr)
18081634{
......@@ -1917,13 +1743,6 @@ static IrInstruction *ir_build_err_name(IrBuilder *irb, Scope *scope, AstNode *s
19171743 return &instruction->base;
19181744}
19191745
1920static IrInstruction *ir_build_err_name_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
1921 IrInstruction *new_instruction = ir_build_err_name(irb, old_instruction->scope,
1922 old_instruction->source_node, value);
1923 ir_link_new_instruction(new_instruction, old_instruction);
1924 return new_instruction;
1925}
1926
19271746static IrInstruction *ir_build_c_import(IrBuilder *irb, Scope *scope, AstNode *source_node) {
19281747 IrInstructionCImport *instruction = ir_build_instruction<IrInstructionCImport>(irb, scope, source_node);
19291748 return &instruction->base;
......@@ -2005,12 +1824,6 @@ static IrInstruction *ir_build_fence(IrBuilder *irb, Scope *scope, AstNode *sour
20051824 return &instruction->base;
20061825}
20071826
2008static IrInstruction *ir_build_fence_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *order_value, AtomicOrder order) {
2009 IrInstruction *new_instruction = ir_build_fence(irb, old_instruction->scope, old_instruction->source_node, order_value, order);
2010 ir_link_new_instruction(new_instruction, old_instruction);
2011 return new_instruction;
2012}
2013
20141827static IrInstruction *ir_build_truncate(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *dest_type, IrInstruction *target) {
20151828 IrInstructionTruncate *instruction = ir_build_instruction<IrInstructionTruncate>(irb, scope, source_node);
20161829 instruction->dest_type = dest_type;
......@@ -2126,12 +1939,6 @@ static IrInstruction *ir_build_bool_not(IrBuilder *irb, Scope *scope, AstNode *s
21261939 return &instruction->base;
21271940}
21281941
2129static IrInstruction *ir_build_bool_not_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
2130 IrInstruction *new_instruction = ir_build_bool_not(irb, old_instruction->scope, old_instruction->source_node, value);
2131 ir_link_new_instruction(new_instruction, old_instruction);
2132 return new_instruction;
2133}
2134
21351942static IrInstruction *ir_build_memset(IrBuilder *irb, Scope *scope, AstNode *source_node,
21361943 IrInstruction *dest_ptr, IrInstruction *byte, IrInstruction *count)
21371944{
......@@ -2147,14 +1954,6 @@ static IrInstruction *ir_build_memset(IrBuilder *irb, Scope *scope, AstNode *sou
21471954 return &instruction->base;
21481955}
21491956
2150static IrInstruction *ir_build_memset_from(IrBuilder *irb, IrInstruction *old_instruction,
2151 IrInstruction *dest_ptr, IrInstruction *byte, IrInstruction *count)
2152{
2153 IrInstruction *new_instruction = ir_build_memset(irb, old_instruction->scope, old_instruction->source_node, dest_ptr, byte, count);
2154 ir_link_new_instruction(new_instruction, old_instruction);
2155 return new_instruction;
2156}
2157
21581957static IrInstruction *ir_build_memcpy(IrBuilder *irb, Scope *scope, AstNode *source_node,
21591958 IrInstruction *dest_ptr, IrInstruction *src_ptr, IrInstruction *count)
21601959{
......@@ -2170,14 +1969,6 @@ static IrInstruction *ir_build_memcpy(IrBuilder *irb, Scope *scope, AstNode *sou
21701969 return &instruction->base;
21711970}
21721971
2173static IrInstruction *ir_build_memcpy_from(IrBuilder *irb, IrInstruction *old_instruction,
2174 IrInstruction *dest_ptr, IrInstruction *src_ptr, IrInstruction *count)
2175{
2176 IrInstruction *new_instruction = ir_build_memcpy(irb, old_instruction->scope, old_instruction->source_node, dest_ptr, src_ptr, count);
2177 ir_link_new_instruction(new_instruction, old_instruction);
2178 return new_instruction;
2179}
2180
21811972static IrInstruction *ir_build_slice(IrBuilder *irb, Scope *scope, AstNode *source_node,
21821973 IrInstruction *ptr, IrInstruction *start, IrInstruction *end, bool safety_check_on)
21831974{
......@@ -2194,15 +1985,6 @@ static IrInstruction *ir_build_slice(IrBuilder *irb, Scope *scope, AstNode *sour
21941985 return &instruction->base;
21951986}
21961987
2197static IrInstruction *ir_build_slice_from(IrBuilder *irb, IrInstruction *old_instruction,
2198 IrInstruction *ptr, IrInstruction *start, IrInstruction *end, bool safety_check_on)
2199{
2200 IrInstruction *new_instruction = ir_build_slice(irb, old_instruction->scope,
2201 old_instruction->source_node, ptr, start, end, safety_check_on);
2202 ir_link_new_instruction(new_instruction, old_instruction);
2203 return new_instruction;
2204}
2205
22061988static IrInstruction *ir_build_member_count(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *container) {
22071989 IrInstructionMemberCount *instruction = ir_build_instruction<IrInstructionMemberCount>(irb, scope, source_node);
22081990 instruction->container = container;
......@@ -2243,45 +2025,21 @@ static IrInstruction *ir_build_breakpoint(IrBuilder *irb, Scope *scope, AstNode
22432025 return &instruction->base;
22442026}
22452027
2246static IrInstruction *ir_build_breakpoint_from(IrBuilder *irb, IrInstruction *old_instruction) {
2247 IrInstruction *new_instruction = ir_build_breakpoint(irb, old_instruction->scope, old_instruction->source_node);
2248 ir_link_new_instruction(new_instruction, old_instruction);
2249 return new_instruction;
2250}
2251
22522028static IrInstruction *ir_build_return_address(IrBuilder *irb, Scope *scope, AstNode *source_node) {
22532029 IrInstructionReturnAddress *instruction = ir_build_instruction<IrInstructionReturnAddress>(irb, scope, source_node);
22542030 return &instruction->base;
22552031}
22562032
2257static IrInstruction *ir_build_return_address_from(IrBuilder *irb, IrInstruction *old_instruction) {
2258 IrInstruction *new_instruction = ir_build_return_address(irb, old_instruction->scope, old_instruction->source_node);
2259 ir_link_new_instruction(new_instruction, old_instruction);
2260 return new_instruction;
2261}
2262
22632033static IrInstruction *ir_build_frame_address(IrBuilder *irb, Scope *scope, AstNode *source_node) {
22642034 IrInstructionFrameAddress *instruction = ir_build_instruction<IrInstructionFrameAddress>(irb, scope, source_node);
22652035 return &instruction->base;
22662036}
22672037
2268static IrInstruction *ir_build_frame_address_from(IrBuilder *irb, IrInstruction *old_instruction) {
2269 IrInstruction *new_instruction = ir_build_frame_address(irb, old_instruction->scope, old_instruction->source_node);
2270 ir_link_new_instruction(new_instruction, old_instruction);
2271 return new_instruction;
2272}
2273
22742038static IrInstruction *ir_build_handle(IrBuilder *irb, Scope *scope, AstNode *source_node) {
22752039 IrInstructionHandle *instruction = ir_build_instruction<IrInstructionHandle>(irb, scope, source_node);
22762040 return &instruction->base;
22772041}
22782042
2279static IrInstruction *ir_build_handle_from(IrBuilder *irb, IrInstruction *old_instruction) {
2280 IrInstruction *new_instruction = ir_build_handle(irb, old_instruction->scope, old_instruction->source_node);
2281 ir_link_new_instruction(new_instruction, old_instruction);
2282 return new_instruction;
2283}
2284
22852043static IrInstruction *ir_build_overflow_op(IrBuilder *irb, Scope *scope, AstNode *source_node,
22862044 IrOverflowOp op, IrInstruction *type_value, IrInstruction *op1, IrInstruction *op2,
22872045 IrInstruction *result_ptr, ZigType *result_ptr_type)
......@@ -2302,16 +2060,6 @@ static IrInstruction *ir_build_overflow_op(IrBuilder *irb, Scope *scope, AstNode
23022060 return &instruction->base;
23032061}
23042062
2305static IrInstruction *ir_build_overflow_op_from(IrBuilder *irb, IrInstruction *old_instruction,
2306 IrOverflowOp op, IrInstruction *type_value, IrInstruction *op1, IrInstruction *op2,
2307 IrInstruction *result_ptr, ZigType *result_ptr_type)
2308{
2309 IrInstruction *new_instruction = ir_build_overflow_op(irb, old_instruction->scope, old_instruction->source_node,
2310 op, type_value, op1, op2, result_ptr, result_ptr_type);
2311 ir_link_new_instruction(new_instruction, old_instruction);
2312 return new_instruction;
2313}
2314
23152063static IrInstruction *ir_build_align_of(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value) {
23162064 IrInstructionAlignOf *instruction = ir_build_instruction<IrInstructionAlignOf>(irb, scope, source_node);
23172065 instruction->type_value = type_value;
......@@ -2332,13 +2080,6 @@ static IrInstruction *ir_build_test_err(IrBuilder *irb, Scope *scope, AstNode *s
23322080 return &instruction->base;
23332081}
23342082
2335static IrInstruction *ir_build_test_err_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
2336 IrInstruction *new_instruction = ir_build_test_err(irb, old_instruction->scope, old_instruction->source_node,
2337 value);
2338 ir_link_new_instruction(new_instruction, old_instruction);
2339 return new_instruction;
2340}
2341
23422083static IrInstruction *ir_build_unwrap_err_code(IrBuilder *irb, Scope *scope, AstNode *source_node,
23432084 IrInstruction *value)
23442085{
......@@ -2350,15 +2091,6 @@ static IrInstruction *ir_build_unwrap_err_code(IrBuilder *irb, Scope *scope, Ast
23502091 return &instruction->base;
23512092}
23522093
2353static IrInstruction *ir_build_unwrap_err_code_from(IrBuilder *irb, IrInstruction *old_instruction,
2354 IrInstruction *value)
2355{
2356 IrInstruction *new_instruction = ir_build_unwrap_err_code(irb, old_instruction->scope,
2357 old_instruction->source_node, value);
2358 ir_link_new_instruction(new_instruction, old_instruction);
2359 return new_instruction;
2360}
2361
23622094static IrInstruction *ir_build_unwrap_err_payload(IrBuilder *irb, Scope *scope, AstNode *source_node,
23632095 IrInstruction *value, bool safety_check_on)
23642096{
......@@ -2371,15 +2103,6 @@ static IrInstruction *ir_build_unwrap_err_payload(IrBuilder *irb, Scope *scope,
23712103 return &instruction->base;
23722104}
23732105
2374static IrInstruction *ir_build_unwrap_err_payload_from(IrBuilder *irb, IrInstruction *old_instruction,
2375 IrInstruction *value, bool safety_check_on)
2376{
2377 IrInstruction *new_instruction = ir_build_unwrap_err_payload(irb, old_instruction->scope,
2378 old_instruction->source_node, value, safety_check_on);
2379 ir_link_new_instruction(new_instruction, old_instruction);
2380 return new_instruction;
2381}
2382
23832106static IrInstruction *ir_build_fn_proto(IrBuilder *irb, Scope *scope, AstNode *source_node,
23842107 IrInstruction **param_types, IrInstruction *align_value, IrInstruction *return_type,
23852108 IrInstruction *async_allocator_type_value, bool is_var_args)
......@@ -3343,6 +3066,10 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
33433066 variable_entry->src_arg_index = SIZE_MAX;
33443067 variable_entry->value = create_const_vals(1);
33453068
3069 if (is_comptime != nullptr) {
3070 is_comptime->ref_count += 1;
3071 }
3072
33463073 if (name) {
33473074 buf_init_from_buf(&variable_entry->name, name);
33483075
......@@ -9691,10 +9418,10 @@ static void ir_finish_bb(IrAnalyze *ira) {
96919418 }
96929419}
96939420
9694static ZigType *ir_unreach_error(IrAnalyze *ira) {
9421static IrInstruction *ir_unreach_error(IrAnalyze *ira) {
96959422 ira->old_bb_index = SIZE_MAX;
96969423 ira->new_irb.exec->invalid = true;
9697 return ira->codegen->builtin_types.entry_unreachable;
9424 return ira->codegen->unreach_instruction;
96989425}
96999426
97009427static bool ir_emit_backward_branch(IrAnalyze *ira, IrInstruction *source_instruction) {
......@@ -9714,7 +9441,7 @@ static bool ir_emit_backward_branch(IrAnalyze *ira, IrInstruction *source_instru
97149441 return true;
97159442}
97169443
9717static ZigType *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction, IrBasicBlock *old_bb) {
9444static IrInstruction *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction, IrBasicBlock *old_bb) {
97189445 if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
97199446 if (!ir_emit_backward_branch(ira, source_instruction))
97209447 return ir_unreach_error(ira);
......@@ -9722,32 +9449,50 @@ static ZigType *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction,
97229449
97239450 old_bb->other = ira->old_irb.current_basic_block->other;
97249451 ir_start_bb(ira, old_bb, ira->old_irb.current_basic_block);
9725 return ira->codegen->builtin_types.entry_unreachable;
9452 return ira->codegen->unreach_instruction;
97269453}
97279454
9728static ZigType *ir_finish_anal(IrAnalyze *ira, ZigType *result_type) {
9729 if (result_type->id == ZigTypeIdUnreachable)
9455static IrInstruction *ir_finish_anal(IrAnalyze *ira, IrInstruction *instruction) {
9456 if (instruction->value.type->id == ZigTypeIdUnreachable)
97309457 ir_finish_bb(ira);
9731 return result_type;
9458 return instruction;
97329459}
97339460
9734static IrInstruction *ir_get_const(IrAnalyze *ira, IrInstruction *old_instruction) {
9461static IrInstruction *ir_const(IrAnalyze *ira, IrInstruction *old_instruction, ZigType *ty) {
97359462 IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
97369463 old_instruction->scope, old_instruction->source_node);
97379464 IrInstruction *new_instruction = &const_instruction->base;
9465 new_instruction->value.type = ty;
97389466 new_instruction->value.special = ConstValSpecialStatic;
97399467 return new_instruction;
97409468}
97419469
9742static ConstExprValue *ir_build_const_from(IrAnalyze *ira, IrInstruction *old_instruction) {
9743 IrInstruction *new_instruction = ir_get_const(ira, old_instruction);
9744 ir_link_new_instruction(new_instruction, old_instruction);
9745 return &new_instruction->value;
9470static IrInstruction *ir_const_type(IrAnalyze *ira, IrInstruction *source_instruction, ZigType *ty) {
9471 IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_type);
9472 result->value.data.x_type = ty;
9473 return result;
9474}
9475
9476static IrInstruction *ir_const_bool(IrAnalyze *ira, IrInstruction *source_instruction, bool value) {
9477 IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_bool);
9478 result->value.data.x_bool = value;
9479 return result;
9480}
9481
9482static IrInstruction *ir_const_void(IrAnalyze *ira, IrInstruction *source_instruction) {
9483 return ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_void);
9484}
9485
9486static IrInstruction *ir_const_unsigned(IrAnalyze *ira, IrInstruction *source_instruction, uint64_t value) {
9487 IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_num_lit_int);
9488 bigint_init_unsigned(&result->value.data.x_bigint, value);
9489 return result;
97469490}
97479491
9748static ZigType *ir_analyze_void(IrAnalyze *ira, IrInstruction *instruction) {
9749 ir_build_const_from(ira, instruction);
9750 return ira->codegen->builtin_types.entry_void;
9492static IrInstruction *ir_const_usize(IrAnalyze *ira, IrInstruction *source_instruction, uint64_t value) {
9493 IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_usize);
9494 bigint_init_unsigned(&result->value.data.x_bigint, value);
9495 return result;
97519496}
97529497
97539498static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instruction,
......@@ -9756,31 +9501,14 @@ static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instructio
97569501{
97579502 ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, pointee_type,
97589503 ptr_is_const, ptr_is_volatile, PtrLenSingle, ptr_align, 0, 0);
9759 IrInstruction *const_instr = ir_get_const(ira, instruction);
9504 IrInstruction *const_instr = ir_const(ira, instruction, ptr_type);
97609505 ConstExprValue *const_val = &const_instr->value;
9761 const_val->type = ptr_type;
97629506 const_val->data.x_ptr.special = ConstPtrSpecialRef;
97639507 const_val->data.x_ptr.mut = ptr_mut;
97649508 const_val->data.x_ptr.data.ref.pointee = pointee;
97659509 return const_instr;
97669510}
97679511
9768static ZigType *ir_analyze_const_ptr(IrAnalyze *ira, IrInstruction *instruction,
9769 ConstExprValue *pointee, ZigType *pointee_type,
9770 ConstPtrMut ptr_mut, bool ptr_is_const, bool ptr_is_volatile)
9771{
9772 IrInstruction *const_instr = ir_get_const_ptr(ira, instruction, pointee,
9773 pointee_type, ptr_mut, ptr_is_const, ptr_is_volatile, 0);
9774 ir_link_new_instruction(const_instr, instruction);
9775 return const_instr->value.type;
9776}
9777
9778static ZigType *ir_analyze_const_usize(IrAnalyze *ira, IrInstruction *instruction, uint64_t value) {
9779 ConstExprValue *const_val = ir_build_const_from(ira, instruction);
9780 bigint_init_unsigned(&const_val->data.x_bigint, value);
9781 return ira->codegen->builtin_types.entry_usize;
9782}
9783
97849512enum UndefAllowed {
97859513 UndefOk,
97869514 UndefBad,
......@@ -11283,14 +11011,6 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc
1128311011 }
1128411012}
1128511013
11286static ZigType *ir_analyze_ref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *value,
11287 bool is_const, bool is_volatile)
11288{
11289 IrInstruction *result = ir_get_ref(ira, source_instruction, value, is_const, is_volatile);
11290 ir_link_new_instruction(result, source_instruction);
11291 return result->value.type;
11292}
11293
1129411014static bool ir_resolve_align(IrAnalyze *ira, IrInstruction *value, uint32_t *out) {
1129511015 if (type_is_invalid(value->value.type))
1129611016 return false;
......@@ -11485,29 +11205,25 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) {
1148511205 return result;
1148611206}
1148711207
11488static ZigType *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira,
11208static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira,
1148911209 IrInstructionAddImplicitReturnType *instruction)
1149011210{
11491 IrInstruction *value = instruction->value->other;
11211 IrInstruction *value = instruction->value->child;
1149211212 if (type_is_invalid(value->value.type))
1149311213 return ir_unreach_error(ira);
1149411214
1149511215 ira->src_implicit_return_type_list.append(value);
1149611216
11497 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
11498 out_val->type = ira->codegen->builtin_types.entry_void;
11499 return out_val->type;
11217 return ir_const_void(ira, &instruction->base);
1150011218}
1150111219
11502static ZigType *ir_analyze_instruction_return(IrAnalyze *ira,
11503 IrInstructionReturn *return_instruction)
11504{
11505 IrInstruction *value = return_instruction->value->other;
11220static IrInstruction *ir_analyze_instruction_return(IrAnalyze *ira, IrInstructionReturn *instruction) {
11221 IrInstruction *value = instruction->value->child;
1150611222 if (type_is_invalid(value->value.type))
1150711223 return ir_unreach_error(ira);
1150811224
1150911225 IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->explicit_return_type);
11510 if (casted_value == ira->codegen->invalid_instruction)
11226 if (type_is_invalid(casted_value->value.type))
1151111227 return ir_unreach_error(ira);
1151211228
1151311229 if (casted_value->value.special == ConstValSpecialRuntime &&
......@@ -11517,63 +11233,65 @@ static ZigType *ir_analyze_instruction_return(IrAnalyze *ira,
1151711233 ir_add_error(ira, casted_value, buf_sprintf("function returns address of local variable"));
1151811234 return ir_unreach_error(ira);
1151911235 }
11520 IrInstruction *result = ir_build_return(&ira->new_irb, return_instruction->base.scope,
11521 return_instruction->base.source_node, casted_value);
11236 IrInstruction *result = ir_build_return(&ira->new_irb, instruction->base.scope,
11237 instruction->base.source_node, casted_value);
1152211238 result->value.type = ira->codegen->builtin_types.entry_unreachable;
11523 ir_link_new_instruction(result, &return_instruction->base);
11524 return ir_finish_anal(ira, result->value.type);
11239 return ir_finish_anal(ira, result);
1152511240}
1152611241
11527static ZigType *ir_analyze_instruction_const(IrAnalyze *ira, IrInstructionConst *const_instruction) {
11528 ConstExprValue *out_val = ir_build_const_from(ira, &const_instruction->base);
11529 *out_val = const_instruction->base.value;
11530 return const_instruction->base.value.type;
11242static IrInstruction *ir_analyze_instruction_const(IrAnalyze *ira, IrInstructionConst *instruction) {
11243 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
11244 // TODO determine if we need to use copy_const_val here
11245 result->value = instruction->base.value;
11246 return result;
1153111247}
1153211248
11533static ZigType *ir_analyze_bin_op_bool(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
11534 IrInstruction *op1 = bin_op_instruction->op1->other;
11249static IrInstruction *ir_analyze_bin_op_bool(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
11250 IrInstruction *op1 = bin_op_instruction->op1->child;
1153511251 if (type_is_invalid(op1->value.type))
11536 return ira->codegen->builtin_types.entry_invalid;
11252 return ira->codegen->invalid_instruction;
1153711253
11538 IrInstruction *op2 = bin_op_instruction->op2->other;
11254 IrInstruction *op2 = bin_op_instruction->op2->child;
1153911255 if (type_is_invalid(op2->value.type))
11540 return ira->codegen->builtin_types.entry_invalid;
11256 return ira->codegen->invalid_instruction;
1154111257
1154211258 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
1154311259
1154411260 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
1154511261 if (casted_op1 == ira->codegen->invalid_instruction)
11546 return ira->codegen->builtin_types.entry_invalid;
11262 return ira->codegen->invalid_instruction;
1154711263
1154811264 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, bool_type);
1154911265 if (casted_op2 == ira->codegen->invalid_instruction)
11550 return ira->codegen->builtin_types.entry_invalid;
11266 return ira->codegen->invalid_instruction;
1155111267
1155211268 if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
11553 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
1155411269 ConstExprValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
1155511270 if (op1_val == nullptr)
11556 return ira->codegen->builtin_types.entry_invalid;
11271 return ira->codegen->invalid_instruction;
1155711272
1155811273 ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
1155911274 if (op2_val == nullptr)
11560 return ira->codegen->builtin_types.entry_invalid;
11275 return ira->codegen->invalid_instruction;
1156111276
1156211277 assert(casted_op1->value.type->id == ZigTypeIdBool);
1156311278 assert(casted_op2->value.type->id == ZigTypeIdBool);
11279 bool result_bool;
1156411280 if (bin_op_instruction->op_id == IrBinOpBoolOr) {
11565 out_val->data.x_bool = op1_val->data.x_bool || op2_val->data.x_bool;
11281 result_bool = op1_val->data.x_bool || op2_val->data.x_bool;
1156611282 } else if (bin_op_instruction->op_id == IrBinOpBoolAnd) {
11567 out_val->data.x_bool = op1_val->data.x_bool && op2_val->data.x_bool;
11283 result_bool = op1_val->data.x_bool && op2_val->data.x_bool;
1156811284 } else {
1156911285 zig_unreachable();
1157011286 }
11571 return bool_type;
11287 return ir_const_bool(ira, &bin_op_instruction->base, result_bool);
1157211288 }
1157311289
11574 ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, bin_op_instruction->op_id,
11575 casted_op1, casted_op2, bin_op_instruction->safety_check_on);
11576 return bool_type;
11290 IrInstruction *result = ir_build_bin_op(&ira->new_irb,
11291 bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
11292 bin_op_instruction->op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
11293 result->value.type = bool_type;
11294 return result;
1157711295}
1157811296
1157911297static bool resolve_cmp_op_id(IrBinOp op_id, Cmp cmp) {
......@@ -11604,15 +11322,15 @@ static bool optional_value_is_null(ConstExprValue *val) {
1160411322 }
1160511323}
1160611324
11607static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
11325static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
1160811326 Error err;
11609 IrInstruction *op1 = bin_op_instruction->op1->other;
11327 IrInstruction *op1 = bin_op_instruction->op1->child;
1161011328 if (type_is_invalid(op1->value.type))
11611 return ira->codegen->builtin_types.entry_invalid;
11329 return ira->codegen->invalid_instruction;
1161211330
11613 IrInstruction *op2 = bin_op_instruction->op2->other;
11331 IrInstruction *op2 = bin_op_instruction->op2->child;
1161411332 if (type_is_invalid(op2->value.type))
11615 return ira->codegen->builtin_types.entry_invalid;
11333 return ira->codegen->invalid_instruction;
1161611334
1161711335 AstNode *source_node = bin_op_instruction->base.source_node;
1161811336
......@@ -11624,9 +11342,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1162411342 (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull)))
1162511343 {
1162611344 if (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull) {
11627 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11628 out_val->data.x_bool = (op_id == IrBinOpCmpEq);
11629 return ira->codegen->builtin_types.entry_bool;
11345 return ir_const_bool(ira, &bin_op_instruction->base, (op_id == IrBinOpCmpEq));
1163011346 }
1163111347 IrInstruction *maybe_op;
1163211348 if (op1->value.type->id == ZigTypeIdNull) {
......@@ -11639,11 +11355,10 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1163911355 if (instr_is_comptime(maybe_op)) {
1164011356 ConstExprValue *maybe_val = ir_resolve_const(ira, maybe_op, UndefBad);
1164111357 if (!maybe_val)
11642 return ira->codegen->builtin_types.entry_invalid;
11358 return ira->codegen->invalid_instruction;
1164311359 bool is_null = optional_value_is_null(maybe_val);
11644 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11645 out_val->data.x_bool = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
11646 return ira->codegen->builtin_types.entry_bool;
11360 bool bool_result = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
11361 return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
1164711362 }
1164811363
1164911364 IrInstruction *is_non_null = ir_build_test_nonnull(&ira->new_irb, bin_op_instruction->base.scope,
......@@ -11651,28 +11366,30 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1165111366 is_non_null->value.type = ira->codegen->builtin_types.entry_bool;
1165211367
1165311368 if (op_id == IrBinOpCmpEq) {
11654 ir_build_bool_not_from(&ira->new_irb, &bin_op_instruction->base, is_non_null);
11369 IrInstruction *result = ir_build_bool_not(&ira->new_irb, bin_op_instruction->base.scope,
11370 bin_op_instruction->base.source_node, is_non_null);
11371 result->value.type = ira->codegen->builtin_types.entry_bool;
11372 return result;
1165511373 } else {
11656 ir_link_new_instruction(is_non_null, &bin_op_instruction->base);
11374 return is_non_null;
1165711375 }
11658 return ira->codegen->builtin_types.entry_bool;
1165911376 } else if (op1->value.type->id == ZigTypeIdNull || op2->value.type->id == ZigTypeIdNull) {
1166011377 ir_add_error_node(ira, source_node, buf_sprintf("comparison against null can only be done with optionals"));
11661 return ira->codegen->builtin_types.entry_invalid;
11378 return ira->codegen->invalid_instruction;
1166211379 }
1166311380
1166411381 if (op1->value.type->id == ZigTypeIdErrorSet && op2->value.type->id == ZigTypeIdErrorSet) {
1166511382 if (!is_equality_cmp) {
1166611383 ir_add_error_node(ira, source_node, buf_sprintf("operator not allowed for errors"));
11667 return ira->codegen->builtin_types.entry_invalid;
11384 return ira->codegen->invalid_instruction;
1166811385 }
1166911386 ZigType *intersect_type = get_error_set_intersection(ira, op1->value.type, op2->value.type, source_node);
1167011387 if (type_is_invalid(intersect_type)) {
11671 return ira->codegen->builtin_types.entry_invalid;
11388 return ira->codegen->invalid_instruction;
1167211389 }
1167311390
1167411391 if (!resolve_inferred_error_set(ira->codegen, intersect_type, source_node)) {
11675 return ira->codegen->builtin_types.entry_invalid;
11392 return ira->codegen->invalid_instruction;
1167611393 }
1167711394
1167811395 // exception if one of the operators has the type of the empty error set, we allow the comparison
......@@ -11689,9 +11406,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1168911406 } else {
1169011407 zig_unreachable();
1169111408 }
11692 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11693 out_val->data.x_bool = answer;
11694 return ira->codegen->builtin_types.entry_bool;
11409 return ir_const_bool(ira, &bin_op_instruction->base, answer);
1169511410 }
1169611411
1169711412 if (!type_is_global_error_set(intersect_type)) {
......@@ -11699,7 +11414,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1169911414 ir_add_error_node(ira, source_node,
1170011415 buf_sprintf("error sets '%s' and '%s' have no common errors",
1170111416 buf_ptr(&op1->value.type->name), buf_ptr(&op2->value.type->name)));
11702 return ira->codegen->builtin_types.entry_invalid;
11417 return ira->codegen->invalid_instruction;
1170311418 }
1170411419 if (op1->value.type->data.error_set.err_count == 1 && op2->value.type->data.error_set.err_count == 1) {
1170511420 bool are_equal = true;
......@@ -11711,19 +11426,17 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1171111426 } else {
1171211427 zig_unreachable();
1171311428 }
11714 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11715 out_val->data.x_bool = answer;
11716 return ira->codegen->builtin_types.entry_bool;
11429 return ir_const_bool(ira, &bin_op_instruction->base, answer);
1171711430 }
1171811431 }
1171911432
1172011433 if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
1172111434 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
1172211435 if (op1_val == nullptr)
11723 return ira->codegen->builtin_types.entry_invalid;
11436 return ira->codegen->invalid_instruction;
1172411437 ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
1172511438 if (op2_val == nullptr)
11726 return ira->codegen->builtin_types.entry_invalid;
11439 return ira->codegen->invalid_instruction;
1172711440
1172811441 bool answer;
1172911442 bool are_equal = op1_val->data.x_err_set->value == op2_val->data.x_err_set->value;
......@@ -11735,21 +11448,20 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1173511448 zig_unreachable();
1173611449 }
1173711450
11738 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11739 out_val->data.x_bool = answer;
11740 return ira->codegen->builtin_types.entry_bool;
11451 return ir_const_bool(ira, &bin_op_instruction->base, answer);
1174111452 }
1174211453
11743 ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
11744 op1, op2, bin_op_instruction->safety_check_on);
11745
11746 return ira->codegen->builtin_types.entry_bool;
11454 IrInstruction *result = ir_build_bin_op(&ira->new_irb,
11455 bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
11456 op_id, op1, op2, bin_op_instruction->safety_check_on);
11457 result->value.type = ira->codegen->builtin_types.entry_bool;
11458 return result;
1174711459 }
1174811460
1174911461 IrInstruction *instructions[] = {op1, op2};
1175011462 ZigType *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
1175111463 if (type_is_invalid(resolved_type))
11752 return resolved_type;
11464 return ira->codegen->invalid_instruction;
1175311465
1175411466 bool operator_allowed;
1175511467 switch (resolved_type->id) {
......@@ -11794,28 +11506,28 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1179411506 if (!operator_allowed) {
1179511507 ir_add_error_node(ira, source_node,
1179611508 buf_sprintf("operator not allowed for type '%s'", buf_ptr(&resolved_type->name)));
11797 return ira->codegen->builtin_types.entry_invalid;
11509 return ira->codegen->invalid_instruction;
1179811510 }
1179911511
1180011512 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
1180111513 if (casted_op1 == ira->codegen->invalid_instruction)
11802 return ira->codegen->builtin_types.entry_invalid;
11514 return ira->codegen->invalid_instruction;
1180311515
1180411516 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
1180511517 if (casted_op2 == ira->codegen->invalid_instruction)
11806 return ira->codegen->builtin_types.entry_invalid;
11518 return ira->codegen->invalid_instruction;
1180711519
1180811520 if ((err = type_resolve(ira->codegen, resolved_type, ResolveStatusZeroBitsKnown)))
11809 return resolved_type;
11521 return ira->codegen->invalid_instruction;
1181011522
1181111523 bool one_possible_value = !type_requires_comptime(resolved_type) && !type_has_bits(resolved_type);
1181211524 if (one_possible_value || (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2))) {
1181311525 ConstExprValue *op1_val = one_possible_value ? &casted_op1->value : ir_resolve_const(ira, casted_op1, UndefBad);
1181411526 if (op1_val == nullptr)
11815 return ira->codegen->builtin_types.entry_invalid;
11527 return ira->codegen->invalid_instruction;
1181611528 ConstExprValue *op2_val = one_possible_value ? &casted_op2->value : ir_resolve_const(ira, casted_op2, UndefBad);
1181711529 if (op2_val == nullptr)
11818 return ira->codegen->builtin_types.entry_invalid;
11530 return ira->codegen->invalid_instruction;
1181911531
1182011532 bool answer;
1182111533 if (resolved_type->id == ZigTypeIdComptimeFloat || resolved_type->id == ZigTypeIdFloat) {
......@@ -11835,9 +11547,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1183511547 }
1183611548 }
1183711549
11838 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11839 out_val->data.x_bool = answer;
11840 return ira->codegen->builtin_types.entry_bool;
11550 return ir_const_bool(ira, &bin_op_instruction->base, answer);
1184111551 }
1184211552
1184311553 // some comparisons with unsigned numbers can be evaluated
......@@ -11847,13 +11557,13 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1184711557 if (instr_is_comptime(casted_op1)) {
1184811558 known_left_val = ir_resolve_const(ira, casted_op1, UndefBad);
1184911559 if (known_left_val == nullptr)
11850 return ira->codegen->builtin_types.entry_invalid;
11560 return ira->codegen->invalid_instruction;
1185111561
1185211562 flipped_op_id = op_id;
1185311563 } else if (instr_is_comptime(casted_op2)) {
1185411564 known_left_val = ir_resolve_const(ira, casted_op2, UndefBad);
1185511565 if (known_left_val == nullptr)
11856 return ira->codegen->builtin_types.entry_invalid;
11566 return ira->codegen->invalid_instruction;
1185711567
1185811568 if (op_id == IrBinOpCmpLessThan) {
1185911569 flipped_op_id = IrBinOpCmpGreaterThan;
......@@ -11873,16 +11583,15 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
1187311583 (flipped_op_id == IrBinOpCmpLessOrEq || flipped_op_id == IrBinOpCmpGreaterThan))
1187411584 {
1187511585 bool answer = (flipped_op_id == IrBinOpCmpLessOrEq);
11876 ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
11877 out_val->data.x_bool = answer;
11878 return ira->codegen->builtin_types.entry_bool;
11586 return ir_const_bool(ira, &bin_op_instruction->base, answer);
1187911587 }
1188011588 }
1188111589
11882 ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
11883 casted_op1, casted_op2, bin_op_instruction->safety_check_on);
11884
11885 return ira->codegen->builtin_types.entry_bool;
11590 IrInstruction *result = ir_build_bin_op(&ira->new_irb,
11591 bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
11592 op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
11593 result->value.type = ira->codegen->builtin_types.entry_bool;
11594 return result;
1188611595}
1188711596
1188811597static int ir_eval_math_op(ZigType *type_entry, ConstExprValue *op1_val,
......@@ -12065,21 +11774,21 @@ static int ir_eval_math_op(ZigType *type_entry, ConstExprValue *op1_val,
1206511774 return 0;
1206611775}
1206711776
12068static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
12069 IrInstruction *op1 = bin_op_instruction->op1->other;
11777static IrInstruction *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
11778 IrInstruction *op1 = bin_op_instruction->op1->child;
1207011779 if (type_is_invalid(op1->value.type))
12071 return ira->codegen->builtin_types.entry_invalid;
11780 return ira->codegen->invalid_instruction;
1207211781
1207311782 if (op1->value.type->id != ZigTypeIdInt && op1->value.type->id != ZigTypeIdComptimeInt) {
1207411783 ir_add_error(ira, &bin_op_instruction->base,
1207511784 buf_sprintf("bit shifting operation expected integer type, found '%s'",
1207611785 buf_ptr(&op1->value.type->name)));
12077 return ira->codegen->builtin_types.entry_invalid;
11786 return ira->codegen->invalid_instruction;
1207811787 }
1207911788
12080 IrInstruction *op2 = bin_op_instruction->op2->other;
11789 IrInstruction *op2 = bin_op_instruction->op2->child;
1208111790 if (type_is_invalid(op2->value.type))
12082 return ira->codegen->builtin_types.entry_invalid;
11791 return ira->codegen->invalid_instruction;
1208311792
1208411793 IrInstruction *casted_op2;
1208511794 IrBinOp op_id = bin_op_instruction->op_id;
......@@ -12094,7 +11803,7 @@ static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_
1209411803 Buf *val_buf = buf_alloc();
1209511804 bigint_append_buf(val_buf, &casted_op2->value.data.x_bigint, 10);
1209611805 ir_add_error(ira, casted_op2, buf_sprintf("shift by negative value %s", buf_ptr(val_buf)));
12097 return ira->codegen->builtin_types.entry_invalid;
11806 return ira->codegen->invalid_instruction;
1209811807 }
1209911808 } else {
1210011809 ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
......@@ -12116,71 +11825,70 @@ static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_
1211611825 buf_sprintf("value %s cannot fit into type %s",
1211711826 buf_ptr(val_buf),
1211811827 buf_ptr(&shift_amt_type->name)));
12119 return ira->codegen->builtin_types.entry_invalid;
11828 return ira->codegen->invalid_instruction;
1212011829 }
1212111830 }
1212211831
1212311832 casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
1212411833 if (casted_op2 == ira->codegen->invalid_instruction)
12125 return ira->codegen->builtin_types.entry_invalid;
11834 return ira->codegen->invalid_instruction;
1212611835 }
1212711836
1212811837 if (instr_is_comptime(op1) && instr_is_comptime(casted_op2)) {
1212911838 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
1213011839 if (op1_val == nullptr)
12131 return ira->codegen->builtin_types.entry_invalid;
11840 return ira->codegen->invalid_instruction;
1213211841
1213311842 ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
1213411843 if (op2_val == nullptr)
12135 return ira->codegen->builtin_types.entry_invalid;
11844 return ira->codegen->invalid_instruction;
1213611845
12137 IrInstruction *result_instruction = ir_get_const(ira, &bin_op_instruction->base);
12138 ir_link_new_instruction(result_instruction, &bin_op_instruction->base);
12139 ConstExprValue *out_val = &result_instruction->value;
11846 IrInstruction *result_instruction = ir_const(ira, &bin_op_instruction->base, op1->value.type);
1214011847
1214111848 int err;
12142 if ((err = ir_eval_math_op(op1->value.type, op1_val, op_id, op2_val, out_val))) {
11849 if ((err = ir_eval_math_op(op1->value.type, op1_val, op_id, op2_val, &result_instruction->value))) {
1214311850 if (err == ErrorOverflow) {
1214411851 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("operation caused overflow"));
12145 return ira->codegen->builtin_types.entry_invalid;
11852 return ira->codegen->invalid_instruction;
1214611853 } else if (err == ErrorShiftedOutOneBits) {
1214711854 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact shift shifted out 1 bits"));
12148 return ira->codegen->builtin_types.entry_invalid;
11855 return ira->codegen->invalid_instruction;
1214911856 } else {
1215011857 zig_unreachable();
1215111858 }
12152 return ira->codegen->builtin_types.entry_invalid;
11859 return ira->codegen->invalid_instruction;
1215311860 }
1215411861
1215511862 ir_num_lit_fits_in_other_type(ira, result_instruction, op1->value.type, false);
12156 return op1->value.type;
11863 return result_instruction;
1215711864 } else if (op1->value.type->id == ZigTypeIdComptimeInt) {
1215811865 ir_add_error(ira, &bin_op_instruction->base,
1215911866 buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
12160 return ira->codegen->builtin_types.entry_invalid;
11867 return ira->codegen->invalid_instruction;
1216111868 } else if (instr_is_comptime(casted_op2) && bigint_cmp_zero(&casted_op2->value.data.x_bigint) == CmpEQ) {
1216211869 IrInstruction *result = ir_build_cast(&ira->new_irb, bin_op_instruction->base.scope,
1216311870 bin_op_instruction->base.source_node, op1->value.type, op1, CastOpNoop);
1216411871 result->value.type = op1->value.type;
12165 ir_link_new_instruction(result, &bin_op_instruction->base);
12166 return result->value.type;
11872 return result;
1216711873 }
1216811874
12169 ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
11875 IrInstruction *result = ir_build_bin_op(&ira->new_irb, bin_op_instruction->base.scope,
11876 bin_op_instruction->base.source_node, op_id,
1217011877 op1, casted_op2, bin_op_instruction->safety_check_on);
12171 return op1->value.type;
11878 result->value.type = op1->value.type;
11879 return result;
1217211880}
1217311881
12174static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
12175 IrInstruction *op1 = bin_op_instruction->op1->other;
11882static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *instruction) {
11883 IrInstruction *op1 = instruction->op1->child;
1217611884 if (type_is_invalid(op1->value.type))
12177 return ira->codegen->builtin_types.entry_invalid;
11885 return ira->codegen->invalid_instruction;
1217811886
12179 IrInstruction *op2 = bin_op_instruction->op2->other;
11887 IrInstruction *op2 = instruction->op2->child;
1218011888 if (type_is_invalid(op2->value.type))
12181 return ira->codegen->builtin_types.entry_invalid;
11889 return ira->codegen->invalid_instruction;
1218211890
12183 IrBinOp op_id = bin_op_instruction->op_id;
11891 IrBinOp op_id = instruction->op_id;
1218411892
1218511893 // look for pointer math
1218611894 if (op1->value.type->id == ZigTypeIdPointer && op1->value.type->data.pointer.ptr_len == PtrLenUnknown &&
......@@ -12188,19 +11896,18 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1218811896 {
1218911897 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
1219011898 if (casted_op2 == ira->codegen->invalid_instruction)
12191 return ira->codegen->builtin_types.entry_invalid;
11899 return ira->codegen->invalid_instruction;
1219211900
12193 IrInstruction *result = ir_build_bin_op(&ira->new_irb, bin_op_instruction->base.scope,
12194 bin_op_instruction->base.source_node, op_id, op1, casted_op2, true);
11901 IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
11902 instruction->base.source_node, op_id, op1, casted_op2, true);
1219511903 result->value.type = op1->value.type;
12196 ir_link_new_instruction(result, &bin_op_instruction->base);
12197 return result->value.type;
11904 return result;
1219811905 }
1219911906
1220011907 IrInstruction *instructions[] = {op1, op2};
12201 ZigType *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, nullptr, instructions, 2);
11908 ZigType *resolved_type = ir_resolve_peer_types(ira, instruction->base.source_node, nullptr, instructions, 2);
1220211909 if (type_is_invalid(resolved_type))
12203 return resolved_type;
11910 return ira->codegen->invalid_instruction;
1220411911
1220511912 bool is_int = resolved_type->id == ZigTypeIdInt || resolved_type->id == ZigTypeIdComptimeInt;
1220611913 bool is_float = resolved_type->id == ZigTypeIdFloat || resolved_type->id == ZigTypeIdComptimeFloat;
......@@ -12220,11 +11927,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1222011927 if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
1222111928 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
1222211929 if (op1_val == nullptr)
12223 return ira->codegen->builtin_types.entry_invalid;
11930 return ira->codegen->invalid_instruction;
1222411931
1222511932 ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
1222611933 if (op2_val == nullptr)
12227 return ira->codegen->builtin_types.entry_invalid;
11934 return ira->codegen->invalid_instruction;
1222811935
1222911936 if (bigint_cmp_zero(&op2_val->data.x_bigint) == CmpEQ) {
1223011937 // the division by zero error will be caught later, but we don't have a
......@@ -12243,11 +11950,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1224311950 }
1224411951 }
1224511952 if (!ok) {
12246 ir_add_error(ira, &bin_op_instruction->base,
11953 ir_add_error(ira, &instruction->base,
1224711954 buf_sprintf("division with '%s' and '%s': signed integers must use @divTrunc, @divFloor, or @divExact",
1224811955 buf_ptr(&op1->value.type->name),
1224911956 buf_ptr(&op2->value.type->name)));
12250 return ira->codegen->builtin_types.entry_invalid;
11957 return ira->codegen->invalid_instruction;
1225111958 }
1225211959 } else {
1225311960 op_id = IrBinOpDivTrunc;
......@@ -12258,12 +11965,12 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1225811965 if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
1225911966 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
1226011967 if (op1_val == nullptr)
12261 return ira->codegen->builtin_types.entry_invalid;
11968 return ira->codegen->invalid_instruction;
1226211969
1226311970 if (is_int) {
1226411971 ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
1226511972 if (op2_val == nullptr)
12266 return ira->codegen->builtin_types.entry_invalid;
11973 return ira->codegen->invalid_instruction;
1226711974
1226811975 if (bigint_cmp_zero(&op2->value.data.x_bigint) == CmpEQ) {
1226911976 // the division by zero error will be caught later, but we don't
......@@ -12279,11 +11986,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1227911986 } else {
1228011987 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
1228111988 if (casted_op2 == ira->codegen->invalid_instruction)
12282 return ira->codegen->builtin_types.entry_invalid;
11989 return ira->codegen->invalid_instruction;
1228311990
1228411991 ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
1228511992 if (op2_val == nullptr)
12286 return ira->codegen->builtin_types.entry_invalid;
11993 return ira->codegen->invalid_instruction;
1228711994
1228811995 if (float_cmp_zero(&casted_op2->value) == CmpEQ) {
1228911996 // the division by zero error will be caught later, but we don't
......@@ -12299,11 +12006,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1229912006 }
1230012007 }
1230112008 if (!ok) {
12302 ir_add_error(ira, &bin_op_instruction->base,
12009 ir_add_error(ira, &instruction->base,
1230312010 buf_sprintf("remainder division with '%s' and '%s': signed integers and floats must use @rem or @mod",
1230412011 buf_ptr(&op1->value.type->name),
1230512012 buf_ptr(&op2->value.type->name)));
12306 return ira->codegen->builtin_types.entry_invalid;
12013 return ira->codegen->invalid_instruction;
1230712014 }
1230812015 }
1230912016 op_id = IrBinOpRemRem;
......@@ -12324,12 +12031,12 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1232412031 {
1232512032 // float
1232612033 } else {
12327 AstNode *source_node = bin_op_instruction->base.source_node;
12034 AstNode *source_node = instruction->base.source_node;
1232812035 ir_add_error_node(ira, source_node,
1232912036 buf_sprintf("invalid operands to binary expression: '%s' and '%s'",
1233012037 buf_ptr(&op1->value.type->name),
1233112038 buf_ptr(&op2->value.type->name)));
12332 return ira->codegen->builtin_types.entry_invalid;
12039 return ira->codegen->invalid_instruction;
1233312040 }
1233412041
1233512042 if (resolved_type->id == ZigTypeIdComptimeInt) {
......@@ -12344,72 +12051,70 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
1234412051
1234512052 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
1234612053 if (casted_op1 == ira->codegen->invalid_instruction)
12347 return ira->codegen->builtin_types.entry_invalid;
12054 return ira->codegen->invalid_instruction;
1234812055
1234912056 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
1235012057 if (casted_op2 == ira->codegen->invalid_instruction)
12351 return ira->codegen->builtin_types.entry_invalid;
12058 return ira->codegen->invalid_instruction;
1235212059
1235312060 if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
1235412061 ConstExprValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
1235512062 if (op1_val == nullptr)
12356 return ira->codegen->builtin_types.entry_invalid;
12063 return ira->codegen->invalid_instruction;
1235712064 ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
1235812065 if (op2_val == nullptr)
12359 return ira->codegen->builtin_types.entry_invalid;
12066 return ira->codegen->invalid_instruction;
1236012067
12361 IrInstruction *result_instruction = ir_get_const(ira, &bin_op_instruction->base);
12362 ir_link_new_instruction(result_instruction, &bin_op_instruction->base);
12363 ConstExprValue *out_val = &result_instruction->value;
12068 IrInstruction *result_instruction = ir_const(ira, &instruction->base, resolved_type);
1236412069
1236512070 int err;
12366 if ((err = ir_eval_math_op(resolved_type, op1_val, op_id, op2_val, out_val))) {
12071 if ((err = ir_eval_math_op(resolved_type, op1_val, op_id, op2_val, &result_instruction->value))) {
1236712072 if (err == ErrorDivByZero) {
12368 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("division by zero"));
12369 return ira->codegen->builtin_types.entry_invalid;
12073 ir_add_error(ira, &instruction->base, buf_sprintf("division by zero"));
12074 return ira->codegen->invalid_instruction;
1237012075 } else if (err == ErrorOverflow) {
12371 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("operation caused overflow"));
12372 return ira->codegen->builtin_types.entry_invalid;
12076 ir_add_error(ira, &instruction->base, buf_sprintf("operation caused overflow"));
12077 return ira->codegen->invalid_instruction;
1237312078 } else if (err == ErrorExactDivRemainder) {
12374 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact division had a remainder"));
12375 return ira->codegen->builtin_types.entry_invalid;
12079 ir_add_error(ira, &instruction->base, buf_sprintf("exact division had a remainder"));
12080 return ira->codegen->invalid_instruction;
1237612081 } else if (err == ErrorNegativeDenominator) {
12377 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("negative denominator"));
12378 return ira->codegen->builtin_types.entry_invalid;
12082 ir_add_error(ira, &instruction->base, buf_sprintf("negative denominator"));
12083 return ira->codegen->invalid_instruction;
1237912084 } else {
1238012085 zig_unreachable();
1238112086 }
12382 return ira->codegen->builtin_types.entry_invalid;
12087 return ira->codegen->invalid_instruction;
1238312088 }
1238412089
1238512090 ir_num_lit_fits_in_other_type(ira, result_instruction, resolved_type, false);
12386 return resolved_type;
12091 return result_instruction;
1238712092 }
1238812093
12389 ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
12390 casted_op1, casted_op2, bin_op_instruction->safety_check_on);
12391 return resolved_type;
12094 IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
12095 instruction->base.source_node, op_id, casted_op1, casted_op2, instruction->safety_check_on);
12096 result->value.type = resolved_type;
12097 return result;
1239212098}
1239312099
12394
12395static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12396 IrInstruction *op1 = instruction->op1->other;
12100static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12101 IrInstruction *op1 = instruction->op1->child;
1239712102 ZigType *op1_type = op1->value.type;
1239812103 if (type_is_invalid(op1_type))
12399 return ira->codegen->builtin_types.entry_invalid;
12104 return ira->codegen->invalid_instruction;
1240012105
12401 IrInstruction *op2 = instruction->op2->other;
12106 IrInstruction *op2 = instruction->op2->child;
1240212107 ZigType *op2_type = op2->value.type;
1240312108 if (type_is_invalid(op2_type))
12404 return ira->codegen->builtin_types.entry_invalid;
12109 return ira->codegen->invalid_instruction;
1240512110
1240612111 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
1240712112 if (!op1_val)
12408 return ira->codegen->builtin_types.entry_invalid;
12113 return ira->codegen->invalid_instruction;
1240912114
1241012115 ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
1241112116 if (!op2_val)
12412 return ira->codegen->builtin_types.entry_invalid;
12117 return ira->codegen->invalid_instruction;
1241312118
1241412119 ConstExprValue *op1_array_val;
1241512120 size_t op1_array_index;
......@@ -12441,7 +12146,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1244112146 } else {
1244212147 ir_add_error(ira, op1,
1244312148 buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op1->value.type->name)));
12444 return ira->codegen->builtin_types.entry_invalid;
12149 return ira->codegen->invalid_instruction;
1244512150 }
1244612151
1244712152 ConstExprValue *op2_array_val;
......@@ -12452,7 +12157,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1245212157 ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
1245312158 buf_ptr(&child_type->name),
1245412159 buf_ptr(&op2->value.type->name)));
12455 return ira->codegen->builtin_types.entry_invalid;
12160 return ira->codegen->invalid_instruction;
1245612161 }
1245712162 op2_array_val = op2_val;
1245812163 op2_array_index = 0;
......@@ -12466,7 +12171,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1246612171 ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
1246712172 buf_ptr(&child_type->name),
1246812173 buf_ptr(&op2->value.type->name)));
12469 return ira->codegen->builtin_types.entry_invalid;
12174 return ira->codegen->invalid_instruction;
1247012175 }
1247112176 op2_array_val = op2_val->data.x_ptr.data.base_array.array_val;
1247212177 op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
......@@ -12477,7 +12182,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1247712182 ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
1247812183 buf_ptr(&child_type->name),
1247912184 buf_ptr(&op2->value.type->name)));
12480 return ira->codegen->builtin_types.entry_invalid;
12185 return ira->codegen->invalid_instruction;
1248112186 }
1248212187 ConstExprValue *ptr_val = &op2_val->data.x_struct.fields[slice_ptr_index];
1248312188 assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
......@@ -12489,22 +12194,23 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1248912194 } else {
1249012195 ir_add_error(ira, op2,
1249112196 buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op2->value.type->name)));
12492 return ira->codegen->builtin_types.entry_invalid;
12197 return ira->codegen->invalid_instruction;
1249312198 }
1249412199
12495 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12200 // The type of result is populated in the following if blocks
12201 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
12202 ConstExprValue *out_val = &result->value;
1249612203
12497 ZigType *result_type;
1249812204 ConstExprValue *out_array_val;
1249912205 size_t new_len = (op1_array_end - op1_array_index) + (op2_array_end - op2_array_index);
1250012206 if (op1_type->id == ZigTypeIdArray || op2_type->id == ZigTypeIdArray) {
12501 result_type = get_array_type(ira->codegen, child_type, new_len);
12207 result->value.type = get_array_type(ira->codegen, child_type, new_len);
1250212208
1250312209 out_array_val = out_val;
1250412210 } else if (is_slice(op1_type) || is_slice(op2_type)) {
1250512211 ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
1250612212 true, false, PtrLenUnknown, 0, 0, 0);
12507 result_type = get_slice_type(ira->codegen, ptr_type);
12213 result->value.type = get_slice_type(ira->codegen, ptr_type);
1250812214 out_array_val = create_const_vals(1);
1250912215 out_array_val->special = ConstValSpecialStatic;
1251012216 out_array_val->type = get_array_type(ira->codegen, child_type, new_len);
......@@ -12524,7 +12230,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1252412230 new_len += 1; // null byte
1252512231
1252612232 // TODO make this `[*]null T` instead of `[*]T`
12527 result_type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenUnknown, 0, 0, 0);
12233 result->value.type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenUnknown, 0, 0, 0);
1252812234
1252912235 out_array_val = create_const_vals(1);
1253012236 out_array_val->special = ConstValSpecialStatic;
......@@ -12538,7 +12244,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1253812244 if (op1_array_val->data.x_array.special == ConstArraySpecialUndef &&
1253912245 op2_array_val->data.x_array.special == ConstArraySpecialUndef) {
1254012246 out_array_val->data.x_array.special = ConstArraySpecialUndef;
12541 return result_type;
12247 return result;
1254212248 }
1254312249
1254412250 out_array_val->data.x_array.data.s_none.elements = create_const_vals(new_len);
......@@ -12560,30 +12266,30 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
1256012266 }
1256112267 assert(next_index == new_len);
1256212268
12563 return result_type;
12269 return result;
1256412270}
1256512271
12566static ZigType *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12567 IrInstruction *op1 = instruction->op1->other;
12272static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12273 IrInstruction *op1 = instruction->op1->child;
1256812274 if (type_is_invalid(op1->value.type))
12569 return ira->codegen->builtin_types.entry_invalid;
12275 return ira->codegen->invalid_instruction;
1257012276
12571 IrInstruction *op2 = instruction->op2->other;
12277 IrInstruction *op2 = instruction->op2->child;
1257212278 if (type_is_invalid(op2->value.type))
12573 return ira->codegen->builtin_types.entry_invalid;
12279 return ira->codegen->invalid_instruction;
1257412280
1257512281 ConstExprValue *array_val = ir_resolve_const(ira, op1, UndefBad);
1257612282 if (!array_val)
12577 return ira->codegen->builtin_types.entry_invalid;
12283 return ira->codegen->invalid_instruction;
1257812284
1257912285 uint64_t mult_amt;
1258012286 if (!ir_resolve_usize(ira, op2, &mult_amt))
12581 return ira->codegen->builtin_types.entry_invalid;
12287 return ira->codegen->invalid_instruction;
1258212288
1258312289 ZigType *array_type = op1->value.type;
1258412290 if (array_type->id != ZigTypeIdArray) {
1258512291 ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value.type->name)));
12586 return ira->codegen->builtin_types.entry_invalid;
12292 return ira->codegen->invalid_instruction;
1258712293 }
1258812294
1258912295 uint64_t old_array_len = array_type->data.array.len;
......@@ -12592,15 +12298,17 @@ static ZigType *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instru
1259212298 if (mul_u64_overflow(old_array_len, mult_amt, &new_array_len))
1259312299 {
1259412300 ir_add_error(ira, &instruction->base, buf_sprintf("operation results in overflow"));
12595 return ira->codegen->builtin_types.entry_invalid;
12301 return ira->codegen->invalid_instruction;
1259612302 }
1259712303
12598 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12304 ZigType *child_type = array_type->data.array.child_type;
12305
12306 IrInstruction *result = ir_const(ira, &instruction->base,
12307 get_array_type(ira->codegen, child_type, new_array_len));
12308 ConstExprValue *out_val = &result->value;
1259912309 if (array_val->data.x_array.special == ConstArraySpecialUndef) {
1260012310 out_val->data.x_array.special = ConstArraySpecialUndef;
12601
12602 ZigType *child_type = array_type->data.array.child_type;
12603 return get_array_type(ira->codegen, child_type, new_array_len);
12311 return result;
1260412312 }
1260512313
1260612314 // TODO optimize the buf case
......@@ -12616,45 +12324,42 @@ static ZigType *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instru
1261612324 }
1261712325 assert(i == new_array_len);
1261812326
12619 ZigType *child_type = array_type->data.array.child_type;
12620 return get_array_type(ira->codegen, child_type, new_array_len);
12327 return result;
1262112328}
1262212329
12623static ZigType *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12624 ZigType *op1_type = ir_resolve_type(ira, instruction->op1->other);
12330static IrInstruction *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *instruction) {
12331 ZigType *op1_type = ir_resolve_type(ira, instruction->op1->child);
1262512332 if (type_is_invalid(op1_type))
12626 return ira->codegen->builtin_types.entry_invalid;
12333 return ira->codegen->invalid_instruction;
1262712334
1262812335 if (op1_type->id != ZigTypeIdErrorSet) {
1262912336 ir_add_error(ira, instruction->op1,
1263012337 buf_sprintf("expected error set type, found '%s'", buf_ptr(&op1_type->name)));
12631 return ira->codegen->builtin_types.entry_invalid;
12338 return ira->codegen->invalid_instruction;
1263212339 }
1263312340
12634 ZigType *op2_type = ir_resolve_type(ira, instruction->op2->other);
12341 ZigType *op2_type = ir_resolve_type(ira, instruction->op2->child);
1263512342 if (type_is_invalid(op2_type))
12636 return ira->codegen->builtin_types.entry_invalid;
12343 return ira->codegen->invalid_instruction;
1263712344
1263812345 if (op2_type->id != ZigTypeIdErrorSet) {
1263912346 ir_add_error(ira, instruction->op2,
1264012347 buf_sprintf("expected error set type, found '%s'", buf_ptr(&op2_type->name)));
12641 return ira->codegen->builtin_types.entry_invalid;
12348 return ira->codegen->invalid_instruction;
1264212349 }
1264312350
1264412351 if (type_is_global_error_set(op1_type) ||
1264512352 type_is_global_error_set(op2_type))
1264612353 {
12647 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12648 out_val->data.x_type = ira->codegen->builtin_types.entry_global_error_set;
12649 return ira->codegen->builtin_types.entry_type;
12354 return ir_const_type(ira, &instruction->base, ira->codegen->builtin_types.entry_global_error_set);
1265012355 }
1265112356
12652 if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->other->source_node)) {
12653 return ira->codegen->builtin_types.entry_invalid;
12357 if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->child->source_node)) {
12358 return ira->codegen->invalid_instruction;
1265412359 }
1265512360
12656 if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->other->source_node)) {
12657 return ira->codegen->builtin_types.entry_invalid;
12361 if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->child->source_node)) {
12362 return ira->codegen->invalid_instruction;
1265812363 }
1265912364
1266012365 ErrorTableEntry **errors = allocate<ErrorTableEntry *>(ira->codegen->errors_by_index.length);
......@@ -12666,13 +12371,10 @@ static ZigType *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *
1266612371 ZigType *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type);
1266712372 free(errors);
1266812373
12669
12670 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12671 out_val->data.x_type = result_type;
12672 return ira->codegen->builtin_types.entry_type;
12374 return ir_const_type(ira, &instruction->base, result_type);
1267312375}
1267412376
12675static ZigType *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
12377static IrInstruction *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
1267612378 IrBinOp op_id = bin_op_instruction->op_id;
1267712379 switch (op_id) {
1267812380 case IrBinOpInvalid:
......@@ -12719,25 +12421,25 @@ static ZigType *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp
1271912421 zig_unreachable();
1272012422}
1272112423
12722static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
12424static IrInstruction *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
1272312425 Error err;
1272412426 ZigVar *var = decl_var_instruction->var;
1272512427
12726 IrInstruction *init_value = decl_var_instruction->init_value->other;
12428 IrInstruction *init_value = decl_var_instruction->init_value->child;
1272712429 if (type_is_invalid(init_value->value.type)) {
1272812430 var->value->type = ira->codegen->builtin_types.entry_invalid;
12729 return var->value->type;
12431 return ira->codegen->invalid_instruction;
1273012432 }
1273112433
1273212434 ZigType *explicit_type = nullptr;
1273312435 IrInstruction *var_type = nullptr;
1273412436 if (decl_var_instruction->var_type != nullptr) {
12735 var_type = decl_var_instruction->var_type->other;
12437 var_type = decl_var_instruction->var_type->child;
1273612438 ZigType *proposed_type = ir_resolve_type(ira, var_type);
1273712439 explicit_type = validate_var_type(ira->codegen, var_type->source_node, proposed_type);
1273812440 if (type_is_invalid(explicit_type)) {
1273912441 var->value->type = ira->codegen->builtin_types.entry_invalid;
12740 return var->value->type;
12442 return ira->codegen->invalid_instruction;
1274112443 }
1274212444 }
1274312445
......@@ -12815,19 +12517,17 @@ static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDec
1281512517 assert(var->value->type);
1281612518
1281712519 if (type_is_invalid(result_type)) {
12818 decl_var_instruction->base.other = &decl_var_instruction->base;
12819 return ira->codegen->builtin_types.entry_void;
12520 return ir_const_void(ira, &decl_var_instruction->base);
1282012521 }
1282112522
1282212523 if (decl_var_instruction->align_value == nullptr) {
1282312524 if ((err = type_resolve(ira->codegen, result_type, ResolveStatusAlignmentKnown))) {
1282412525 var->value->type = ira->codegen->builtin_types.entry_invalid;
12825 decl_var_instruction->base.other = &decl_var_instruction->base;
12826 return ira->codegen->builtin_types.entry_void;
12526 return ir_const_void(ira, &decl_var_instruction->base);
1282712527 }
1282812528 var->align_bytes = get_abi_alignment(ira->codegen, result_type);
1282912529 } else {
12830 if (!ir_resolve_align(ira, decl_var_instruction->align_value->other, &var->align_bytes)) {
12530 if (!ir_resolve_align(ira, decl_var_instruction->align_value->child, &var->align_bytes)) {
1283112531 var->value->type = ira->codegen->builtin_types.entry_invalid;
1283212532 }
1283312533 }
......@@ -12839,43 +12539,44 @@ static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDec
1283912539 copy_const_val(mem_slot, &casted_init_value->value, !is_comptime_var || var->gen_is_const);
1284012540
1284112541 if (is_comptime_var || (var_class_requires_const && var->gen_is_const)) {
12842 ir_build_const_from(ira, &decl_var_instruction->base);
12843 return ira->codegen->builtin_types.entry_void;
12542 return ir_const_void(ira, &decl_var_instruction->base);
1284412543 }
1284512544 }
1284612545 } else if (is_comptime_var) {
1284712546 ir_add_error(ira, &decl_var_instruction->base,
1284812547 buf_sprintf("cannot store runtime value in compile time variable"));
1284912548 var->value->type = ira->codegen->builtin_types.entry_invalid;
12850 return ira->codegen->builtin_types.entry_invalid;
12549 return ira->codegen->invalid_instruction;
1285112550 }
1285212551
12853 ir_build_var_decl_from(&ira->new_irb, &decl_var_instruction->base, var, var_type, nullptr, casted_init_value);
12854
1285512552 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
1285612553 if (fn_entry)
1285712554 fn_entry->variable_list.append(var);
1285812555
12859 return ira->codegen->builtin_types.entry_void;
12556 IrInstruction *result = ir_build_var_decl(&ira->new_irb,
12557 decl_var_instruction->base.scope, decl_var_instruction->base.source_node,
12558 var, var_type, nullptr, casted_init_value);
12559 result->value.type = ira->codegen->builtin_types.entry_void;
12560 return result;
1286012561}
1286112562
12862static ZigType *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExport *instruction) {
12863 IrInstruction *name = instruction->name->other;
12563static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExport *instruction) {
12564 IrInstruction *name = instruction->name->child;
1286412565 Buf *symbol_name = ir_resolve_str(ira, name);
1286512566 if (symbol_name == nullptr) {
12866 return ira->codegen->builtin_types.entry_invalid;
12567 return ira->codegen->invalid_instruction;
1286712568 }
1286812569
12869 IrInstruction *target = instruction->target->other;
12570 IrInstruction *target = instruction->target->child;
1287012571 if (type_is_invalid(target->value.type)) {
12871 return ira->codegen->builtin_types.entry_invalid;
12572 return ira->codegen->invalid_instruction;
1287212573 }
1287312574
1287412575 GlobalLinkageId global_linkage_id = GlobalLinkageIdStrong;
1287512576 if (instruction->linkage != nullptr) {
12876 IrInstruction *linkage_value = instruction->linkage->other;
12577 IrInstruction *linkage_value = instruction->linkage->child;
1287712578 if (!ir_resolve_global_linkage(ira, linkage_value, &global_linkage_id)) {
12878 return ira->codegen->builtin_types.entry_invalid;
12579 return ira->codegen->invalid_instruction;
1287912580 }
1288012581 }
1288112582
......@@ -13023,8 +12724,7 @@ static ZigType *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExpor
1302312724 break;
1302412725 }
1302512726
13026 ir_build_const_from(ira, &instruction->base);
13027 return ira->codegen->builtin_types.entry_void;
12727 return ir_const_void(ira, &instruction->base);
1302812728}
1302912729
1303012730static bool exec_has_err_ret_trace(CodeGen *g, IrExecutable *exec) {
......@@ -13032,59 +12732,58 @@ static bool exec_has_err_ret_trace(CodeGen *g, IrExecutable *exec) {
1303212732 return fn_entry != nullptr && fn_entry->calls_or_awaits_errorable_fn && g->have_err_ret_tracing;
1303312733}
1303412734
13035static ZigType *ir_analyze_instruction_error_return_trace(IrAnalyze *ira,
12735static IrInstruction *ir_analyze_instruction_error_return_trace(IrAnalyze *ira,
1303612736 IrInstructionErrorReturnTrace *instruction)
1303712737{
1303812738 if (instruction->optional == IrInstructionErrorReturnTrace::Null) {
1303912739 ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
1304012740 ZigType *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
1304112741 if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
13042 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
12742 IrInstruction *result = ir_const(ira, &instruction->base, optional_type);
12743 ConstExprValue *out_val = &result->value;
1304312744 assert(get_codegen_ptr_type(optional_type) != nullptr);
1304412745 out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
1304512746 out_val->data.x_ptr.data.hard_coded_addr.addr = 0;
13046 return optional_type;
12747 return result;
1304712748 }
1304812749 IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
1304912750 instruction->base.source_node, instruction->optional);
13050 ir_link_new_instruction(new_instruction, &instruction->base);
13051 return optional_type;
12751 new_instruction->value.type = optional_type;
12752 return new_instruction;
1305212753 } else {
1305312754 assert(ira->codegen->have_err_ret_tracing);
1305412755 IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
1305512756 instruction->base.source_node, instruction->optional);
13056 ir_link_new_instruction(new_instruction, &instruction->base);
13057 return get_ptr_to_stack_trace_type(ira->codegen);
12757 new_instruction->value.type = get_ptr_to_stack_trace_type(ira->codegen);
12758 return new_instruction;
1305812759 }
1305912760}
1306012761
13061static ZigType *ir_analyze_instruction_error_union(IrAnalyze *ira,
12762static IrInstruction *ir_analyze_instruction_error_union(IrAnalyze *ira,
1306212763 IrInstructionErrorUnion *instruction)
1306312764{
1306412765 Error err;
1306512766
13066 ZigType *err_set_type = ir_resolve_type(ira, instruction->err_set->other);
12767 ZigType *err_set_type = ir_resolve_type(ira, instruction->err_set->child);
1306712768 if (type_is_invalid(err_set_type))
13068 return ira->codegen->builtin_types.entry_invalid;
12769 return ira->codegen->invalid_instruction;
1306912770
13070 ZigType *payload_type = ir_resolve_type(ira, instruction->payload->other);
12771 ZigType *payload_type = ir_resolve_type(ira, instruction->payload->child);
1307112772 if (type_is_invalid(payload_type))
13072 return ira->codegen->builtin_types.entry_invalid;
12773 return ira->codegen->invalid_instruction;
1307312774
1307412775 if (err_set_type->id != ZigTypeIdErrorSet) {
13075 ir_add_error(ira, instruction->err_set->other,
12776 ir_add_error(ira, instruction->err_set->child,
1307612777 buf_sprintf("expected error set type, found type '%s'",
1307712778 buf_ptr(&err_set_type->name)));
13078 return ira->codegen->builtin_types.entry_invalid;
12779 return ira->codegen->invalid_instruction;
1307912780 }
1308012781
1308112782 if ((err = type_resolve(ira->codegen, payload_type, ResolveStatusSizeKnown)))
13082 return ira->codegen->builtin_types.entry_invalid;
12783 return ira->codegen->invalid_instruction;
1308312784 ZigType *result_type = get_error_union_type(ira->codegen, err_set_type, payload_type);
1308412785
13085 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
13086 out_val->data.x_type = result_type;
13087 return ira->codegen->builtin_types.entry_type;
12786 return ir_const_type(ira, &instruction->base, result_type);
1308812787}
1308912788
1309012789IrInstruction *ir_get_implicit_allocator(IrAnalyze *ira, IrInstruction *source_instr, ImplicitAllocatorId id) {
......@@ -13362,7 +13061,7 @@ no_mem_slot:
1336213061 return var_ptr_instruction;
1336313062}
1336413063
13365static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instruction,
13064static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instruction,
1336613065 ZigFn *fn_entry, ZigType *fn_type, IrInstruction *fn_ref,
1336713066 IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
1336813067{
......@@ -13382,7 +13081,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1338213081
1338313082 size_t call_param_count = call_instruction->arg_count + first_arg_1_or_0;
1338413083 for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
13385 ConstExprValue *arg_tuple_value = &call_instruction->args[i]->other->value;
13084 ConstExprValue *arg_tuple_value = &call_instruction->args[i]->child->value;
1338613085 if (arg_tuple_value->type->id == ZigTypeIdArgTuple) {
1338713086 call_param_count -= 1;
1338813087 call_param_count += arg_tuple_value->data.x_arg_tuple.end_index -
......@@ -13398,21 +13097,21 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1339813097 if (fn_proto_node) {
1339913098 add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
1340013099 }
13401 return ira->codegen->builtin_types.entry_invalid;
13100 return ira->codegen->invalid_instruction;
1340213101 }
1340313102 if (fn_type_id->cc == CallingConventionAsync && !call_instruction->is_async) {
1340413103 ErrorMsg *msg = ir_add_error(ira, fn_ref, buf_sprintf("must use async keyword to call async function"));
1340513104 if (fn_proto_node) {
1340613105 add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
1340713106 }
13408 return ira->codegen->builtin_types.entry_invalid;
13107 return ira->codegen->invalid_instruction;
1340913108 }
1341013109 if (fn_type_id->cc != CallingConventionAsync && call_instruction->is_async) {
1341113110 ErrorMsg *msg = ir_add_error(ira, fn_ref, buf_sprintf("cannot use async keyword to call non-async function"));
1341213111 if (fn_proto_node) {
1341313112 add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
1341413113 }
13415 return ira->codegen->builtin_types.entry_invalid;
13114 return ira->codegen->invalid_instruction;
1341613115 }
1341713116
1341813117
......@@ -13424,7 +13123,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1342413123 add_error_note(ira->codegen, msg, fn_proto_node,
1342513124 buf_sprintf("declared here"));
1342613125 }
13427 return ira->codegen->builtin_types.entry_invalid;
13126 return ira->codegen->invalid_instruction;
1342813127 }
1342913128 } else if (src_param_count != call_param_count) {
1343013129 ErrorMsg *msg = ir_add_error_node(ira, source_node,
......@@ -13433,18 +13132,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1343313132 add_error_note(ira->codegen, msg, fn_proto_node,
1343413133 buf_sprintf("declared here"));
1343513134 }
13436 return ira->codegen->builtin_types.entry_invalid;
13135 return ira->codegen->invalid_instruction;
1343713136 }
1343813137
1343913138 if (comptime_fn_call) {
1344013139 // No special handling is needed for compile time evaluation of generic functions.
1344113140 if (!fn_entry || fn_entry->body_node == nullptr) {
1344213141 ir_add_error(ira, fn_ref, buf_sprintf("unable to evaluate constant expression"));
13443 return ira->codegen->builtin_types.entry_invalid;
13142 return ira->codegen->invalid_instruction;
1344413143 }
1344513144
1344613145 if (!ir_emit_backward_branch(ira, &call_instruction->base))
13447 return ira->codegen->builtin_types.entry_invalid;
13146 return ira->codegen->invalid_instruction;
1344813147
1344913148 // Fork a scope of the function with known values for the parameters.
1345013149 Scope *exec_scope = &fn_entry->fndef_scope->base;
......@@ -13457,7 +13156,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1345713156 if (fn_type_id->next_param_index >= 1) {
1345813157 ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
1345913158 if (type_is_invalid(param_type))
13460 return ira->codegen->builtin_types.entry_invalid;
13159 return ira->codegen->invalid_instruction;
1346113160 first_arg_known_bare = param_type->id != ZigTypeIdPointer;
1346213161 }
1346313162
......@@ -13467,39 +13166,39 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1346713166 } else {
1346813167 first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
1346913168 if (type_is_invalid(first_arg->value.type))
13470 return ira->codegen->builtin_types.entry_invalid;
13169 return ira->codegen->invalid_instruction;
1347113170 }
1347213171
1347313172 if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, first_arg, &exec_scope, &next_proto_i))
13474 return ira->codegen->builtin_types.entry_invalid;
13173 return ira->codegen->invalid_instruction;
1347513174 }
1347613175
1347713176 if (fn_proto_node->data.fn_proto.is_var_args) {
1347813177 ir_add_error(ira, &call_instruction->base,
1347913178 buf_sprintf("compiler bug: unable to call var args function at compile time. https://github.com/ziglang/zig/issues/313"));
13480 return ira->codegen->builtin_types.entry_invalid;
13179 return ira->codegen->invalid_instruction;
1348113180 }
1348213181
1348313182
1348413183 for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
13485 IrInstruction *old_arg = call_instruction->args[call_i]->other;
13184 IrInstruction *old_arg = call_instruction->args[call_i]->child;
1348613185 if (type_is_invalid(old_arg->value.type))
13487 return ira->codegen->builtin_types.entry_invalid;
13186 return ira->codegen->invalid_instruction;
1348813187
1348913188 if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, old_arg, &exec_scope, &next_proto_i))
13490 return ira->codegen->builtin_types.entry_invalid;
13189 return ira->codegen->invalid_instruction;
1349113190 }
1349213191
1349313192 AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
1349413193 ZigType *specified_return_type = analyze_type_expr(ira->codegen, exec_scope, return_type_node);
1349513194 if (type_is_invalid(specified_return_type))
13496 return ira->codegen->builtin_types.entry_invalid;
13195 return ira->codegen->invalid_instruction;
1349713196 ZigType *return_type;
1349813197 ZigType *inferred_err_set_type = nullptr;
1349913198 if (fn_proto_node->data.fn_proto.auto_err_set) {
1350013199 inferred_err_set_type = get_auto_err_set_type(ira->codegen, fn_entry);
1350113200 if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
13502 return ira->codegen->builtin_types.entry_invalid;
13201 return ira->codegen->invalid_instruction;
1350313202 return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
1350413203 } else {
1350513204 return_type = specified_return_type;
......@@ -13542,12 +13241,14 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1354213241 }
1354313242
1354413243 if (type_is_invalid(result->value.type))
13545 return ira->codegen->builtin_types.entry_invalid;
13244 return ira->codegen->invalid_instruction;
1354613245 }
1354713246
13548 ConstExprValue *out_val = ir_build_const_from(ira, &call_instruction->base);
13549 *out_val = result->value;
13550 return ir_finish_anal(ira, return_type);
13247 IrInstruction *new_instruction = ir_const(ira, &call_instruction->base, result->value.type);
13248 // TODO should we use copy_const_val?
13249 new_instruction->value = result->value;
13250 new_instruction->value.type = return_type;
13251 return ir_finish_anal(ira, new_instruction);
1355113252 }
1355213253
1355313254 IrInstruction *casted_new_stack = nullptr;
......@@ -13555,28 +13256,28 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1355513256 ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
1355613257 false, false, PtrLenUnknown, 0, 0, 0);
1355713258 ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
13558 IrInstruction *new_stack = call_instruction->new_stack->other;
13259 IrInstruction *new_stack = call_instruction->new_stack->child;
1355913260 if (type_is_invalid(new_stack->value.type))
13560 return ira->codegen->builtin_types.entry_invalid;
13261 return ira->codegen->invalid_instruction;
1356113262
1356213263 casted_new_stack = ir_implicit_cast(ira, new_stack, u8_slice);
1356313264 if (type_is_invalid(casted_new_stack->value.type))
13564 return ira->codegen->builtin_types.entry_invalid;
13265 return ira->codegen->invalid_instruction;
1356513266 }
1356613267
1356713268 if (fn_type->data.fn.is_generic) {
1356813269 if (!fn_entry) {
1356913270 ir_add_error(ira, call_instruction->fn_ref,
1357013271 buf_sprintf("calling a generic function requires compile-time known function value"));
13571 return ira->codegen->builtin_types.entry_invalid;
13272 return ira->codegen->invalid_instruction;
1357213273 }
1357313274
1357413275 // Count the arguments of the function type id we are creating
1357513276 size_t new_fn_arg_count = first_arg_1_or_0;
1357613277 for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
13577 IrInstruction *arg = call_instruction->args[call_i]->other;
13278 IrInstruction *arg = call_instruction->args[call_i]->child;
1357813279 if (type_is_invalid(arg->value.type))
13579 return ira->codegen->builtin_types.entry_invalid;
13280 return ira->codegen->invalid_instruction;
1358013281
1358113282 if (arg->value.type->id == ZigTypeIdArgTuple) {
1358213283 new_fn_arg_count += arg->value.data.x_arg_tuple.end_index - arg->value.data.x_arg_tuple.start_index;
......@@ -13614,7 +13315,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1361413315 if (fn_type_id->next_param_index >= 1) {
1361513316 ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
1361613317 if (type_is_invalid(param_type))
13617 return ira->codegen->builtin_types.entry_invalid;
13318 return ira->codegen->invalid_instruction;
1361813319 first_arg_known_bare = param_type->id != ZigTypeIdPointer;
1361913320 }
1362013321
......@@ -13624,13 +13325,13 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1362413325 } else {
1362513326 first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
1362613327 if (type_is_invalid(first_arg->value.type))
13627 return ira->codegen->builtin_types.entry_invalid;
13328 return ira->codegen->invalid_instruction;
1362813329 }
1362913330
1363013331 if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, first_arg, &impl_fn->child_scope,
1363113332 &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
1363213333 {
13633 return ira->codegen->builtin_types.entry_invalid;
13334 return ira->codegen->invalid_instruction;
1363413335 }
1363513336 }
1363613337
......@@ -13640,9 +13341,9 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1364013341 ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
1364113342 assert(parent_fn_entry);
1364213343 for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
13643 IrInstruction *arg = call_instruction->args[call_i]->other;
13344 IrInstruction *arg = call_instruction->args[call_i]->child;
1364413345 if (type_is_invalid(arg->value.type))
13645 return ira->codegen->builtin_types.entry_invalid;
13346 return ira->codegen->invalid_instruction;
1364613347
1364713348 if (arg->value.type->id == ZigTypeIdArgTuple) {
1364813349 for (size_t arg_tuple_i = arg->value.data.x_arg_tuple.start_index;
......@@ -13660,20 +13361,20 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1366013361 if (arg_var == nullptr) {
1366113362 ir_add_error(ira, arg,
1366213363 buf_sprintf("compiler bug: var args can't handle void. https://github.com/ziglang/zig/issues/557"));
13663 return ira->codegen->builtin_types.entry_invalid;
13364 return ira->codegen->invalid_instruction;
1366413365 }
1366513366 IrInstruction *arg_var_ptr_inst = ir_get_var_ptr(ira, arg, arg_var);
1366613367 if (type_is_invalid(arg_var_ptr_inst->value.type))
13667 return ira->codegen->builtin_types.entry_invalid;
13368 return ira->codegen->invalid_instruction;
1366813369
1366913370 IrInstruction *arg_tuple_arg = ir_get_deref(ira, arg, arg_var_ptr_inst);
1367013371 if (type_is_invalid(arg_tuple_arg->value.type))
13671 return ira->codegen->builtin_types.entry_invalid;
13372 return ira->codegen->invalid_instruction;
1367213373
1367313374 if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg_tuple_arg, &impl_fn->child_scope,
1367413375 &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
1367513376 {
13676 return ira->codegen->builtin_types.entry_invalid;
13377 return ira->codegen->invalid_instruction;
1367713378 }
1367813379 }
1367913380 } else {
......@@ -13688,7 +13389,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1368813389 if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg, &impl_fn->child_scope,
1368913390 &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
1369013391 {
13691 return ira->codegen->builtin_types.entry_invalid;
13392 return ira->codegen->invalid_instruction;
1369213393 }
1369313394 }
1369413395 }
......@@ -13724,18 +13425,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1372413425 AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
1372513426 ZigType *specified_return_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, return_type_node);
1372613427 if (type_is_invalid(specified_return_type))
13727 return ira->codegen->builtin_types.entry_invalid;
13428 return ira->codegen->invalid_instruction;
1372813429 if (fn_proto_node->data.fn_proto.auto_err_set) {
1372913430 ZigType *inferred_err_set_type = get_auto_err_set_type(ira->codegen, impl_fn);
1373013431 if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
13731 return ira->codegen->builtin_types.entry_invalid;
13432 return ira->codegen->invalid_instruction;
1373213433 inst_fn_type_id.return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
1373313434 } else {
1373413435 inst_fn_type_id.return_type = specified_return_type;
1373513436 }
1373613437
1373713438 if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusZeroBitsKnown)))
13738 return ira->codegen->builtin_types.entry_invalid;
13439 return ira->codegen->invalid_instruction;
1373913440
1374013441 if (type_requires_comptime(specified_return_type)) {
1374113442 // Throw out our work and call the function as if it were comptime.
......@@ -13748,7 +13449,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1374813449 if (async_allocator_type_node != nullptr) {
1374913450 ZigType *async_allocator_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, async_allocator_type_node);
1375013451 if (type_is_invalid(async_allocator_type))
13751 return ira->codegen->builtin_types.entry_invalid;
13452 return ira->codegen->invalid_instruction;
1375213453 inst_fn_type_id.async_allocator_type = async_allocator_type;
1375313454 }
1375413455 IrInstruction *uncasted_async_allocator_inst;
......@@ -13756,18 +13457,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1375613457 uncasted_async_allocator_inst = ir_get_implicit_allocator(ira, &call_instruction->base,
1375713458 ImplicitAllocatorIdLocalVar);
1375813459 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
13759 return ira->codegen->builtin_types.entry_invalid;
13460 return ira->codegen->invalid_instruction;
1376013461 } else {
13761 uncasted_async_allocator_inst = call_instruction->async_allocator->other;
13462 uncasted_async_allocator_inst = call_instruction->async_allocator->child;
1376213463 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
13763 return ira->codegen->builtin_types.entry_invalid;
13464 return ira->codegen->invalid_instruction;
1376413465 }
1376513466 if (inst_fn_type_id.async_allocator_type == nullptr) {
1376613467 inst_fn_type_id.async_allocator_type = uncasted_async_allocator_inst->value.type;
1376713468 }
1376813469 async_allocator_inst = ir_implicit_cast(ira, uncasted_async_allocator_inst, inst_fn_type_id.async_allocator_type);
1376913470 if (type_is_invalid(async_allocator_inst->value.type))
13770 return ira->codegen->builtin_types.entry_invalid;
13471 return ira->codegen->invalid_instruction;
1377113472 }
1377213473
1377313474 auto existing_entry = ira->codegen->generic_table.put_unique(generic_id, impl_fn);
......@@ -13778,7 +13479,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1377813479 // finish instantiating the function
1377913480 impl_fn->type_entry = get_fn_type(ira->codegen, &inst_fn_type_id);
1378013481 if (type_is_invalid(impl_fn->type_entry))
13781 return ira->codegen->builtin_types.entry_invalid;
13482 return ira->codegen->invalid_instruction;
1378213483
1378313484 impl_fn->ir_executable.source_node = call_instruction->base.source_node;
1378413485 impl_fn->ir_executable.parent_exec = ira->new_irb.exec;
......@@ -13797,21 +13498,22 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1379713498
1379813499 size_t impl_param_count = impl_fn->type_entry->data.fn.fn_type_id.param_count;
1379913500 if (call_instruction->is_async) {
13800 IrInstruction *result = ir_analyze_async_call(ira, call_instruction, impl_fn, impl_fn->type_entry, fn_ref, casted_args, impl_param_count,
13801 async_allocator_inst);
13802 ir_link_new_instruction(result, &call_instruction->base);
13501 IrInstruction *result = ir_analyze_async_call(ira, call_instruction, impl_fn, impl_fn->type_entry,
13502 fn_ref, casted_args, impl_param_count, async_allocator_inst);
1380313503 ir_add_alloca(ira, result, result->value.type);
13804 return ir_finish_anal(ira, result->value.type);
13504 return ir_finish_anal(ira, result);
1380513505 }
1380613506
1380713507 assert(async_allocator_inst == nullptr);
13808 IrInstruction *new_call_instruction = ir_build_call_from(&ira->new_irb, &call_instruction->base,
13508 IrInstruction *new_call_instruction = ir_build_call(&ira->new_irb,
13509 call_instruction->base.scope, call_instruction->base.source_node,
1380913510 impl_fn, nullptr, impl_param_count, casted_args, false, fn_inline,
1381013511 call_instruction->is_async, nullptr, casted_new_stack);
13512 new_call_instruction->value.type = return_type;
1381113513
1381213514 ir_add_alloca(ira, new_call_instruction, return_type);
1381313515
13814 return ir_finish_anal(ira, return_type);
13516 return ir_finish_anal(ira, new_call_instruction);
1381513517 }
1381613518
1381713519 ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
......@@ -13829,7 +13531,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1382913531
1383013532 ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
1383113533 if (type_is_invalid(param_type))
13832 return ira->codegen->builtin_types.entry_invalid;
13534 return ira->codegen->invalid_instruction;
1383313535
1383413536 IrInstruction *first_arg;
1383513537 if (param_type->id == ZigTypeIdPointer &&
......@@ -13839,28 +13541,28 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1383913541 } else {
1384013542 first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
1384113543 if (type_is_invalid(first_arg->value.type))
13842 return ira->codegen->builtin_types.entry_invalid;
13544 return ira->codegen->invalid_instruction;
1384313545 }
1384413546
1384513547 IrInstruction *casted_arg = ir_implicit_cast(ira, first_arg, param_type);
1384613548 if (type_is_invalid(casted_arg->value.type))
13847 return ira->codegen->builtin_types.entry_invalid;
13549 return ira->codegen->invalid_instruction;
1384813550
1384913551 casted_args[next_arg_index] = casted_arg;
1385013552 next_arg_index += 1;
1385113553 }
1385213554 for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
13853 IrInstruction *old_arg = call_instruction->args[call_i]->other;
13555 IrInstruction *old_arg = call_instruction->args[call_i]->child;
1385413556 if (type_is_invalid(old_arg->value.type))
13855 return ira->codegen->builtin_types.entry_invalid;
13557 return ira->codegen->invalid_instruction;
1385613558 IrInstruction *casted_arg;
1385713559 if (next_arg_index < src_param_count) {
1385813560 ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
1385913561 if (type_is_invalid(param_type))
13860 return ira->codegen->builtin_types.entry_invalid;
13562 return ira->codegen->invalid_instruction;
1386113563 casted_arg = ir_implicit_cast(ira, old_arg, param_type);
1386213564 if (type_is_invalid(casted_arg->value.type))
13863 return ira->codegen->builtin_types.entry_invalid;
13565 return ira->codegen->invalid_instruction;
1386413566 } else {
1386513567 casted_arg = old_arg;
1386613568 }
......@@ -13873,7 +13575,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1387313575
1387413576 ZigType *return_type = fn_type_id->return_type;
1387513577 if (type_is_invalid(return_type))
13876 return ira->codegen->builtin_types.entry_invalid;
13578 return ira->codegen->invalid_instruction;
1387713579
1387813580 if (call_instruction->is_async) {
1387913581 IrInstruction *uncasted_async_allocator_inst;
......@@ -13881,41 +13583,41 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
1388113583 uncasted_async_allocator_inst = ir_get_implicit_allocator(ira, &call_instruction->base,
1388213584 ImplicitAllocatorIdLocalVar);
1388313585 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
13884 return ira->codegen->builtin_types.entry_invalid;
13586 return ira->codegen->invalid_instruction;
1388513587 } else {
13886 uncasted_async_allocator_inst = call_instruction->async_allocator->other;
13588 uncasted_async_allocator_inst = call_instruction->async_allocator->child;
1388713589 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
13888 return ira->codegen->builtin_types.entry_invalid;
13590 return ira->codegen->invalid_instruction;
1388913591
1389013592 }
1389113593 IrInstruction *async_allocator_inst = ir_implicit_cast(ira, uncasted_async_allocator_inst, fn_type_id->async_allocator_type);
1389213594 if (type_is_invalid(async_allocator_inst->value.type))
13893 return ira->codegen->builtin_types.entry_invalid;
13595 return ira->codegen->invalid_instruction;
1389413596
13895 IrInstruction *result = ir_analyze_async_call(ira, call_instruction, fn_entry, fn_type, fn_ref, casted_args, call_param_count,
13896 async_allocator_inst);
13897 ir_link_new_instruction(result, &call_instruction->base);
13597 IrInstruction *result = ir_analyze_async_call(ira, call_instruction, fn_entry, fn_type, fn_ref,
13598 casted_args, call_param_count, async_allocator_inst);
1389813599 ir_add_alloca(ira, result, result->value.type);
13899 return ir_finish_anal(ira, result->value.type);
13600 return ir_finish_anal(ira, result);
1390013601 }
1390113602
1390213603 if (fn_entry != nullptr && fn_entry->fn_inline == FnInlineAlways && fn_inline == FnInlineNever) {
1390313604 ir_add_error(ira, &call_instruction->base,
1390413605 buf_sprintf("no-inline call of inline function"));
13905 return ira->codegen->builtin_types.entry_invalid;
13606 return ira->codegen->invalid_instruction;
1390613607 }
1390713608
13908 IrInstruction *new_call_instruction = ir_build_call_from(&ira->new_irb, &call_instruction->base,
13609 IrInstruction *new_call_instruction = ir_build_call(&ira->new_irb,
13610 call_instruction->base.scope, call_instruction->base.source_node,
1390913611 fn_entry, fn_ref, call_param_count, casted_args, false, fn_inline, false, nullptr, casted_new_stack);
13910
13612 new_call_instruction->value.type = return_type;
1391113613 ir_add_alloca(ira, new_call_instruction, return_type);
13912 return ir_finish_anal(ira, return_type);
13614 return ir_finish_anal(ira, new_call_instruction);
1391313615}
1391413616
13915static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *call_instruction) {
13916 IrInstruction *fn_ref = call_instruction->fn_ref->other;
13617static IrInstruction *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *call_instruction) {
13618 IrInstruction *fn_ref = call_instruction->fn_ref->child;
1391713619 if (type_is_invalid(fn_ref->value.type))
13918 return ira->codegen->builtin_types.entry_invalid;
13620 return ira->codegen->invalid_instruction;
1391913621
1392013622 bool is_comptime = call_instruction->is_comptime ||
1392113623 ir_should_inline(ira->new_irb.exec, call_instruction->base.scope);
......@@ -13924,28 +13626,26 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
1392413626 if (fn_ref->value.type->id == ZigTypeIdMetaType) {
1392513627 ZigType *dest_type = ir_resolve_type(ira, fn_ref);
1392613628 if (type_is_invalid(dest_type))
13927 return ira->codegen->builtin_types.entry_invalid;
13629 return ira->codegen->invalid_instruction;
1392813630
1392913631 size_t actual_param_count = call_instruction->arg_count;
1393013632
1393113633 if (actual_param_count != 1) {
1393213634 ir_add_error_node(ira, call_instruction->base.source_node,
1393313635 buf_sprintf("cast expression expects exactly one parameter"));
13934 return ira->codegen->builtin_types.entry_invalid;
13636 return ira->codegen->invalid_instruction;
1393513637 }
1393613638
13937 IrInstruction *arg = call_instruction->args[0]->other;
13639 IrInstruction *arg = call_instruction->args[0]->child;
1393813640
1393913641 IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, dest_type, arg);
1394013642 if (type_is_invalid(cast_instruction->value.type))
13941 return ira->codegen->builtin_types.entry_invalid;
13942
13943 ir_link_new_instruction(cast_instruction, &call_instruction->base);
13944 return ir_finish_anal(ira, cast_instruction->value.type);
13643 return ira->codegen->invalid_instruction;
13644 return ir_finish_anal(ira, cast_instruction);
1394513645 } else if (fn_ref->value.type->id == ZigTypeIdFn) {
1394613646 ZigFn *fn_table_entry = ir_resolve_fn(ira, fn_ref);
1394713647 if (fn_table_entry == nullptr)
13948 return ira->codegen->builtin_types.entry_invalid;
13648 return ira->codegen->invalid_instruction;
1394913649 return ir_analyze_fn_call(ira, call_instruction, fn_table_entry, fn_table_entry->type_entry,
1395013650 fn_ref, nullptr, is_comptime, call_instruction->fn_inline);
1395113651 } else if (fn_ref->value.type->id == ZigTypeIdBoundFn) {
......@@ -13957,7 +13657,7 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
1395713657 } else {
1395813658 ir_add_error_node(ira, fn_ref->source_node,
1395913659 buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value.type->name)));
13960 return ira->codegen->builtin_types.entry_invalid;
13660 return ira->codegen->invalid_instruction;
1396113661 }
1396213662 }
1396313663
......@@ -13967,7 +13667,7 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
1396713667 } else {
1396813668 ir_add_error_node(ira, fn_ref->source_node,
1396913669 buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value.type->name)));
13970 return ira->codegen->builtin_types.entry_invalid;
13670 return ira->codegen->invalid_instruction;
1397113671 }
1397213672}
1397313673
......@@ -14008,14 +13708,14 @@ static Error ir_read_const_ptr(IrAnalyze *ira, AstNode *source_node,
1400813708 return ErrorNone;
1400913709}
1401013710
14011static ZigType *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
13711static IrInstruction *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
1401213712 Error err;
14013 IrInstruction *value = un_op_instruction->value->other;
13713 IrInstruction *value = un_op_instruction->value->child;
1401413714 ZigType *type_entry = ir_resolve_type(ira, value);
1401513715 if (type_is_invalid(type_entry))
14016 return ira->codegen->builtin_types.entry_invalid;
13716 return ira->codegen->invalid_instruction;
1401713717 if ((err = ensure_complete_type(ira->codegen, type_entry)))
14018 return ira->codegen->builtin_types.entry_invalid;
13718 return ira->codegen->invalid_instruction;
1401913719
1402013720 switch (type_entry->id) {
1402113721 case ZigTypeIdInvalid:
......@@ -14042,27 +13742,23 @@ static ZigType *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instru
1404213742 case ZigTypeIdBoundFn:
1404313743 case ZigTypeIdArgTuple:
1404413744 case ZigTypeIdPromise:
14045 {
14046 ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
14047 out_val->data.x_type = get_optional_type(ira->codegen, type_entry);
14048 return ira->codegen->builtin_types.entry_type;
14049 }
13745 return ir_const_type(ira, &un_op_instruction->base, get_optional_type(ira->codegen, type_entry));
1405013746 case ZigTypeIdUnreachable:
1405113747 case ZigTypeIdOpaque:
1405213748 ir_add_error_node(ira, un_op_instruction->base.source_node,
1405313749 buf_sprintf("type '%s' not optional", buf_ptr(&type_entry->name)));
14054 return ira->codegen->builtin_types.entry_invalid;
13750 return ira->codegen->invalid_instruction;
1405513751 }
1405613752 zig_unreachable();
1405713753}
1405813754
14059static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
14060 IrInstruction *value = un_op_instruction->value->other;
13755static IrInstruction *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *instruction) {
13756 IrInstruction *value = instruction->value->child;
1406113757 ZigType *expr_type = value->value.type;
1406213758 if (type_is_invalid(expr_type))
14063 return ira->codegen->builtin_types.entry_invalid;
13759 return ira->codegen->invalid_instruction;
1406413760
14065 bool is_wrap_op = (un_op_instruction->op_id == IrUnOpNegationWrap);
13761 bool is_wrap_op = (instruction->op_id == IrUnOpNegationWrap);
1406613762
1406713763 bool is_float = (expr_type->id == ZigTypeIdFloat || expr_type->id == ZigTypeIdComptimeFloat);
1406813764
......@@ -14072,9 +13768,10 @@ static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_ins
1407213768 if (instr_is_comptime(value)) {
1407313769 ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
1407413770 if (!target_const_val)
14075 return ira->codegen->builtin_types.entry_invalid;
13771 return ira->codegen->invalid_instruction;
1407613772
14077 ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
13773 IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
13774 ConstExprValue *out_val = &result->value;
1407813775 if (is_float) {
1407913776 float_negate(out_val, target_const_val);
1408013777 } else if (is_wrap_op) {
......@@ -14084,92 +13781,96 @@ static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_ins
1408413781 bigint_negate(&out_val->data.x_bigint, &target_const_val->data.x_bigint);
1408513782 }
1408613783 if (is_wrap_op || is_float || expr_type->id == ZigTypeIdComptimeInt) {
14087 return expr_type;
13784 return result;
1408813785 }
1408913786
1409013787 if (!bigint_fits_in_bits(&out_val->data.x_bigint, expr_type->data.integral.bit_count, true)) {
14091 ir_add_error(ira, &un_op_instruction->base, buf_sprintf("negation caused overflow"));
14092 return ira->codegen->builtin_types.entry_invalid;
13788 ir_add_error(ira, &instruction->base, buf_sprintf("negation caused overflow"));
13789 return ira->codegen->invalid_instruction;
1409313790 }
14094 return expr_type;
13791 return result;
1409513792 }
1409613793
14097 ir_build_un_op_from(&ira->new_irb, &un_op_instruction->base, un_op_instruction->op_id, value);
14098 return expr_type;
13794 IrInstruction *result = ir_build_un_op(&ira->new_irb,
13795 instruction->base.scope, instruction->base.source_node,
13796 instruction->op_id, value);
13797 result->value.type = expr_type;
13798 return result;
1409913799 }
1410013800
1410113801 const char *fmt = is_wrap_op ? "invalid wrapping negation type: '%s'" : "invalid negation type: '%s'";
14102 ir_add_error(ira, &un_op_instruction->base, buf_sprintf(fmt, buf_ptr(&expr_type->name)));
14103 return ira->codegen->builtin_types.entry_invalid;
13802 ir_add_error(ira, &instruction->base, buf_sprintf(fmt, buf_ptr(&expr_type->name)));
13803 return ira->codegen->invalid_instruction;
1410413804}
1410513805
14106static ZigType *ir_analyze_bin_not(IrAnalyze *ira, IrInstructionUnOp *instruction) {
14107 IrInstruction *value = instruction->value->other;
13806static IrInstruction *ir_analyze_bin_not(IrAnalyze *ira, IrInstructionUnOp *instruction) {
13807 IrInstruction *value = instruction->value->child;
1410813808 ZigType *expr_type = value->value.type;
1410913809 if (type_is_invalid(expr_type))
14110 return ira->codegen->builtin_types.entry_invalid;
13810 return ira->codegen->invalid_instruction;
1411113811
1411213812 if (expr_type->id == ZigTypeIdInt) {
1411313813 if (instr_is_comptime(value)) {
1411413814 ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
1411513815 if (target_const_val == nullptr)
14116 return ira->codegen->builtin_types.entry_invalid;
13816 return ira->codegen->invalid_instruction;
1411713817
14118 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
14119 bigint_not(&out_val->data.x_bigint, &target_const_val->data.x_bigint,
13818 IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
13819 bigint_not(&result->value.data.x_bigint, &target_const_val->data.x_bigint,
1412013820 expr_type->data.integral.bit_count, expr_type->data.integral.is_signed);
14121 return expr_type;
13821 return result;
1412213822 }
1412313823
14124 ir_build_un_op_from(&ira->new_irb, &instruction->base, IrUnOpBinNot, value);
14125 return expr_type;
13824 IrInstruction *result = ir_build_un_op(&ira->new_irb, instruction->base.scope,
13825 instruction->base.source_node, IrUnOpBinNot, value);
13826 result->value.type = expr_type;
13827 return result;
1412613828 }
1412713829
1412813830 ir_add_error(ira, &instruction->base,
1412913831 buf_sprintf("unable to perform binary not operation on type '%s'", buf_ptr(&expr_type->name)));
14130 return ira->codegen->builtin_types.entry_invalid;
13832 return ira->codegen->invalid_instruction;
1413113833}
1413213834
14133static ZigType *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
14134 IrUnOp op_id = un_op_instruction->op_id;
13835static IrInstruction *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructionUnOp *instruction) {
13836 IrUnOp op_id = instruction->op_id;
1413513837 switch (op_id) {
1413613838 case IrUnOpInvalid:
1413713839 zig_unreachable();
1413813840 case IrUnOpBinNot:
14139 return ir_analyze_bin_not(ira, un_op_instruction);
13841 return ir_analyze_bin_not(ira, instruction);
1414013842 case IrUnOpNegation:
1414113843 case IrUnOpNegationWrap:
14142 return ir_analyze_negation(ira, un_op_instruction);
13844 return ir_analyze_negation(ira, instruction);
1414313845 case IrUnOpDereference: {
14144 IrInstruction *ptr = un_op_instruction->value->other;
13846 IrInstruction *ptr = instruction->value->child;
1414513847 if (type_is_invalid(ptr->value.type))
14146 return ira->codegen->builtin_types.entry_invalid;
13848 return ira->codegen->invalid_instruction;
1414713849 ZigType *ptr_type = ptr->value.type;
1414813850 if (ptr_type->id == ZigTypeIdPointer && ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
14149 ir_add_error_node(ira, un_op_instruction->base.source_node,
13851 ir_add_error_node(ira, instruction->base.source_node,
1415013852 buf_sprintf("index syntax required for unknown-length pointer type '%s'",
1415113853 buf_ptr(&ptr_type->name)));
14152 return ira->codegen->builtin_types.entry_invalid;
13854 return ira->codegen->invalid_instruction;
1415313855 }
1415413856 // this dereference is always an rvalue because in the IR gen we identify lvalue and emit
1415513857 // one of the ptr instructions
14156 IrInstruction *result = ir_get_deref(ira, &un_op_instruction->base, ptr);
13858 IrInstruction *result = ir_get_deref(ira, &instruction->base, ptr);
1415713859 if (result == ira->codegen->invalid_instruction)
14158 return ira->codegen->builtin_types.entry_invalid;
14159 ir_link_new_instruction(result, &un_op_instruction->base);
14160 return result->value.type;
13860 return ira->codegen->invalid_instruction;
13861 return result;
1416113862 }
1416213863 case IrUnOpOptional:
14163 return ir_analyze_maybe(ira, un_op_instruction);
13864 return ir_analyze_maybe(ira, instruction);
1416413865 }
1416513866 zig_unreachable();
1416613867}
1416713868
14168static ZigType *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_instruction) {
13869static IrInstruction *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_instruction) {
1416913870 IrBasicBlock *old_dest_block = br_instruction->dest_block;
1417013871
1417113872 bool is_comptime;
14172 if (!ir_resolve_comptime(ira, br_instruction->is_comptime->other, &is_comptime))
13873 if (!ir_resolve_comptime(ira, br_instruction->is_comptime->child, &is_comptime))
1417313874 return ir_unreach_error(ira);
1417413875
1417513876 if (is_comptime || old_dest_block->ref_count == 1)
......@@ -14179,17 +13880,19 @@ static ZigType *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_in
1417913880 if (new_bb == nullptr)
1418013881 return ir_unreach_error(ira);
1418113882
14182 ir_build_br_from(&ira->new_irb, &br_instruction->base, new_bb);
14183 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13883 IrInstruction *result = ir_build_br(&ira->new_irb,
13884 br_instruction->base.scope, br_instruction->base.source_node, new_bb, nullptr);
13885 result->value.type = ira->codegen->builtin_types.entry_unreachable;
13886 return ir_finish_anal(ira, result);
1418413887}
1418513888
14186static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCondBr *cond_br_instruction) {
14187 IrInstruction *condition = cond_br_instruction->condition->other;
13889static IrInstruction *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCondBr *cond_br_instruction) {
13890 IrInstruction *condition = cond_br_instruction->condition->child;
1418813891 if (type_is_invalid(condition->value.type))
1418913892 return ir_unreach_error(ira);
1419013893
1419113894 bool is_comptime;
14192 if (!ir_resolve_comptime(ira, cond_br_instruction->is_comptime->other, &is_comptime))
13895 if (!ir_resolve_comptime(ira, cond_br_instruction->is_comptime->child, &is_comptime))
1419313896 return ir_unreach_error(ira);
1419413897
1419513898 if (is_comptime || instr_is_comptime(condition)) {
......@@ -14207,8 +13910,10 @@ static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCond
1420713910 if (new_dest_block == nullptr)
1420813911 return ir_unreach_error(ira);
1420913912
14210 ir_build_br_from(&ira->new_irb, &cond_br_instruction->base, new_dest_block);
14211 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13913 IrInstruction *result = ir_build_br(&ira->new_irb,
13914 cond_br_instruction->base.scope, cond_br_instruction->base.source_node, new_dest_block, nullptr);
13915 result->value.type = ira->codegen->builtin_types.entry_unreachable;
13916 return ir_finish_anal(ira, result);
1421213917 }
1421313918
1421413919 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
......@@ -14225,36 +13930,41 @@ static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCond
1422513930 if (new_else_block == nullptr)
1422613931 return ir_unreach_error(ira);
1422713932
14228 ir_build_cond_br_from(&ira->new_irb, &cond_br_instruction->base,
13933 IrInstruction *result = ir_build_cond_br(&ira->new_irb,
13934 cond_br_instruction->base.scope, cond_br_instruction->base.source_node,
1422913935 casted_condition, new_then_block, new_else_block, nullptr);
14230 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13936 result->value.type = ira->codegen->builtin_types.entry_unreachable;
13937 return ir_finish_anal(ira, result);
1423113938}
1423213939
14233static ZigType *ir_analyze_instruction_unreachable(IrAnalyze *ira,
13940static IrInstruction *ir_analyze_instruction_unreachable(IrAnalyze *ira,
1423413941 IrInstructionUnreachable *unreachable_instruction)
1423513942{
14236 ir_build_unreachable_from(&ira->new_irb, &unreachable_instruction->base);
14237 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13943 IrInstruction *result = ir_build_unreachable(&ira->new_irb,
13944 unreachable_instruction->base.scope, unreachable_instruction->base.source_node);
13945 result->value.type = ira->codegen->builtin_types.entry_unreachable;
13946 return ir_finish_anal(ira, result);
1423813947}
1423913948
14240static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi_instruction) {
13949static IrInstruction *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi_instruction) {
1424113950 if (ira->const_predecessor_bb) {
1424213951 for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
1424313952 IrBasicBlock *predecessor = phi_instruction->incoming_blocks[i];
1424413953 if (predecessor != ira->const_predecessor_bb)
1424513954 continue;
14246 IrInstruction *value = phi_instruction->incoming_values[i]->other;
13955 IrInstruction *value = phi_instruction->incoming_values[i]->child;
1424713956 assert(value->value.type);
1424813957 if (type_is_invalid(value->value.type))
14249 return ira->codegen->builtin_types.entry_invalid;
13958 return ira->codegen->invalid_instruction;
1425013959
1425113960 if (value->value.special != ConstValSpecialRuntime) {
14252 ConstExprValue *out_val = ir_build_const_from(ira, &phi_instruction->base);
14253 *out_val = value->value;
13961 IrInstruction *result = ir_const(ira, &phi_instruction->base, nullptr);
13962 // TODO use copy_const_val?
13963 result->value = value->value;
13964 return result;
1425413965 } else {
14255 phi_instruction->base.other = value;
13966 return value;
1425613967 }
14257 return value->value.type;
1425813968 }
1425913969 zig_unreachable();
1426013970 }
......@@ -14270,12 +13980,12 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
1427013980
1427113981 IrInstruction *old_value = phi_instruction->incoming_values[i];
1427213982 assert(old_value);
14273 IrInstruction *new_value = old_value->other;
13983 IrInstruction *new_value = old_value->child;
1427413984 if (!new_value || new_value->value.type->id == ZigTypeIdUnreachable || predecessor->other == nullptr)
1427513985 continue;
1427613986
1427713987 if (type_is_invalid(new_value->value.type))
14278 return ira->codegen->builtin_types.entry_invalid;
13988 return ira->codegen->invalid_instruction;
1427913989
1428013990
1428113991 assert(predecessor->other);
......@@ -14284,20 +13994,20 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
1428413994 }
1428513995
1428613996 if (new_incoming_blocks.length == 0) {
14287 ir_build_unreachable_from(&ira->new_irb, &phi_instruction->base);
14288 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
13997 IrInstruction *result = ir_build_unreachable(&ira->new_irb,
13998 phi_instruction->base.scope, phi_instruction->base.source_node);
13999 result->value.type = ira->codegen->builtin_types.entry_unreachable;
14000 return ir_finish_anal(ira, result);
1428914001 }
1429014002
1429114003 if (new_incoming_blocks.length == 1) {
14292 IrInstruction *first_value = new_incoming_values.at(0);
14293 phi_instruction->base.other = first_value;
14294 return first_value->value.type;
14004 return new_incoming_values.at(0);
1429514005 }
1429614006
1429714007 ZigType *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
1429814008 new_incoming_values.items, new_incoming_values.length);
1429914009 if (type_is_invalid(resolved_type))
14300 return resolved_type;
14010 return ira->codegen->invalid_instruction;
1430114011
1430214012 if (resolved_type->id == ZigTypeIdComptimeFloat ||
1430314013 resolved_type->id == ZigTypeIdComptimeInt ||
......@@ -14306,7 +14016,7 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
1430614016 {
1430714017 ir_add_error_node(ira, phi_instruction->base.source_node,
1430814018 buf_sprintf("unable to infer expression type"));
14309 return ira->codegen->builtin_types.entry_invalid;
14019 return ira->codegen->invalid_instruction;
1431014020 }
1431114021
1431214022 bool all_stack_ptrs = (resolved_type->id == ZigTypeIdPointer);
......@@ -14322,7 +14032,7 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
1432214032 ir_set_cursor_at_end(&ira->new_irb, predecessor);
1432314033 IrInstruction *casted_value = ir_implicit_cast(ira, new_value, resolved_type);
1432414034 if (casted_value == ira->codegen->invalid_instruction) {
14325 return ira->codegen->builtin_types.entry_invalid;
14035 return ira->codegen->invalid_instruction;
1432614036 }
1432714037 new_incoming_values.items[i] = casted_value;
1432814038 predecessor->instruction_list.append(branch_instruction);
......@@ -14335,24 +14045,20 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
1433514045 }
1433614046 ir_set_cursor_at_end(&ira->new_irb, cur_bb);
1433714047
14338 IrInstruction *result = ir_build_phi_from(&ira->new_irb, &phi_instruction->base, new_incoming_blocks.length,
14339 new_incoming_blocks.items, new_incoming_values.items);
14048 IrInstruction *result = ir_build_phi(&ira->new_irb,
14049 phi_instruction->base.scope, phi_instruction->base.source_node,
14050 new_incoming_blocks.length, new_incoming_blocks.items, new_incoming_values.items);
14051 result->value.type = resolved_type;
1434014052
1434114053 if (all_stack_ptrs) {
1434214054 assert(result->value.special == ConstValSpecialRuntime);
1434314055 result->value.data.rh_ptr = RuntimeHintPtrStack;
1434414056 }
1434514057
14346 return resolved_type;
14347}
14348
14349static ZigType *ir_analyze_var_ptr(IrAnalyze *ira, IrInstruction *instruction, ZigVar *var) {
14350 IrInstruction *result = ir_get_var_ptr(ira, instruction, var);
14351 ir_link_new_instruction(result, instruction);
14352 return result->value.type;
14058 return result;
1435314059}
1435414060
14355static ZigType *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarPtr *instruction) {
14061static IrInstruction *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarPtr *instruction) {
1435614062 ZigVar *var = instruction->var;
1435714063 IrInstruction *result = ir_get_var_ptr(ira, &instruction->base, var);
1435814064 if (instruction->crossed_fndef_scope != nullptr && !instr_is_comptime(result)) {
......@@ -14362,10 +14068,9 @@ static ZigType *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarP
1436214068 buf_sprintf("crossed function definition here"));
1436314069 add_error_note(ira->codegen, msg, var->decl_node,
1436414070 buf_sprintf("declared here"));
14365 return ira->codegen->builtin_types.entry_invalid;
14071 return ira->codegen->invalid_instruction;
1436614072 }
14367 ir_link_new_instruction(result, &instruction->base);
14368 return result->value.type;
14073 return result;
1436914074}
1437014075
1437114076static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_align) {
......@@ -14395,17 +14100,17 @@ static ZigType *adjust_ptr_len(CodeGen *g, ZigType *ptr_type, PtrLen ptr_len) {
1439514100 ptr_type->data.pointer.bit_offset_in_host, ptr_type->data.pointer.host_int_bytes);
1439614101}
1439714102
14398static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
14103static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
1439914104 Error err;
14400 IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->other;
14105 IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->child;
1440114106 if (type_is_invalid(array_ptr->value.type))
14402 return ira->codegen->builtin_types.entry_invalid;
14107 return ira->codegen->invalid_instruction;
1440314108
1440414109 ConstExprValue *orig_array_ptr_val = &array_ptr->value;
1440514110
14406 IrInstruction *elem_index = elem_ptr_instruction->elem_index->other;
14111 IrInstruction *elem_index = elem_ptr_instruction->elem_index->child;
1440714112 if (type_is_invalid(elem_index->value.type))
14408 return ira->codegen->builtin_types.entry_invalid;
14113 return ira->codegen->invalid_instruction;
1440914114
1441014115 ZigType *ptr_type = orig_array_ptr_val->type;
1441114116 assert(ptr_type->id == ZigTypeIdPointer);
......@@ -14417,7 +14122,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1441714122 ZigType *return_type;
1441814123
1441914124 if (type_is_invalid(array_type)) {
14420 return array_type;
14125 return ira->codegen->invalid_instruction;
1442114126 } else if (array_type->id == ZigTypeIdArray ||
1442214127 (array_type->id == ZigTypeIdPointer &&
1442314128 array_type->data.pointer.ptr_len == PtrLenSingle &&
......@@ -14430,13 +14135,13 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1443014135 orig_array_ptr_val = ir_const_ptr_pointee(ira, orig_array_ptr_val,
1443114136 elem_ptr_instruction->base.source_node);
1443214137 if (orig_array_ptr_val == nullptr)
14433 return ira->codegen->builtin_types.entry_invalid;
14138 return ira->codegen->invalid_instruction;
1443414139 }
1443514140 }
1443614141 if (array_type->data.array.len == 0) {
1443714142 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1443814143 buf_sprintf("index 0 outside array of size 0"));
14439 return ira->codegen->builtin_types.entry_invalid;
14144 return ira->codegen->invalid_instruction;
1444014145 }
1444114146 ZigType *child_type = array_type->data.array.child_type;
1444214147 if (ptr_type->data.pointer.host_int_bytes == 0) {
......@@ -14447,7 +14152,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1444714152 } else {
1444814153 uint64_t elem_val_scalar;
1444914154 if (!ir_resolve_usize(ira, elem_index, &elem_val_scalar))
14450 return ira->codegen->builtin_types.entry_invalid;
14155 return ira->codegen->invalid_instruction;
1445114156
1445214157 size_t bit_width = type_size_bits(ira->codegen, child_type);
1445314158 size_t bit_offset = bit_width * elem_val_scalar;
......@@ -14461,7 +14166,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1446114166 if (array_type->data.pointer.ptr_len == PtrLenSingle) {
1446214167 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1446314168 buf_sprintf("index of single-item pointer"));
14464 return ira->codegen->builtin_types.entry_invalid;
14169 return ira->codegen->invalid_instruction;
1446514170 }
1446614171 return_type = adjust_ptr_len(ira->codegen, array_type, elem_ptr_instruction->ptr_len);
1446714172 } else if (is_slice(array_type)) {
......@@ -14470,21 +14175,21 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1447014175 } else if (array_type->id == ZigTypeIdArgTuple) {
1447114176 ConstExprValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
1447214177 if (!ptr_val)
14473 return ira->codegen->builtin_types.entry_invalid;
14178 return ira->codegen->invalid_instruction;
1447414179 ConstExprValue *args_val = ir_const_ptr_pointee(ira, ptr_val, elem_ptr_instruction->base.source_node);
1447514180 if (args_val == nullptr)
14476 return ira->codegen->builtin_types.entry_invalid;
14181 return ira->codegen->invalid_instruction;
1447714182 size_t start = args_val->data.x_arg_tuple.start_index;
1447814183 size_t end = args_val->data.x_arg_tuple.end_index;
1447914184 uint64_t elem_index_val;
1448014185 if (!ir_resolve_usize(ira, elem_index, &elem_index_val))
14481 return ira->codegen->builtin_types.entry_invalid;
14186 return ira->codegen->invalid_instruction;
1448214187 size_t index = elem_index_val;
1448314188 size_t len = end - start;
1448414189 if (index >= len) {
1448514190 ir_add_error(ira, &elem_ptr_instruction->base,
1448614191 buf_sprintf("index %" ZIG_PRI_usize " outside argument list of size %" ZIG_PRI_usize "", index, len));
14487 return ira->codegen->builtin_types.entry_invalid;
14192 return ira->codegen->invalid_instruction;
1448814193 }
1448914194 size_t abs_index = start + index;
1449014195 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
......@@ -14493,25 +14198,25 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1449314198 bool is_const = true;
1449414199 bool is_volatile = false;
1449514200 if (var) {
14496 return ir_analyze_var_ptr(ira, &elem_ptr_instruction->base, var);
14201 return ir_get_var_ptr(ira, &elem_ptr_instruction->base, var);
1449714202 } else {
14498 return ir_analyze_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,
14499 ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile);
14203 return ir_get_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,
14204 ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile, 0);
1450014205 }
1450114206 } else {
1450214207 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1450314208 buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));
14504 return ira->codegen->builtin_types.entry_invalid;
14209 return ira->codegen->invalid_instruction;
1450514210 }
1450614211
1450714212 ZigType *usize = ira->codegen->builtin_types.entry_usize;
1450814213 IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
1450914214 if (casted_elem_index == ira->codegen->invalid_instruction)
14510 return ira->codegen->builtin_types.entry_invalid;
14215 return ira->codegen->invalid_instruction;
1451114216
1451214217 bool safety_check_on = elem_ptr_instruction->safety_check_on;
1451314218 if ((err = ensure_complete_type(ira->codegen, return_type->data.pointer.child_type)))
14514 return ira->codegen->builtin_types.entry_invalid;
14219 return ira->codegen->invalid_instruction;
1451514220
1451614221 uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
1451714222 uint64_t abi_align = get_abi_alignment(ira->codegen, return_type->data.pointer.child_type);
......@@ -14524,7 +14229,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1452414229 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1452514230 buf_sprintf("index %" ZIG_PRI_u64 " outside array of size %" ZIG_PRI_u64,
1452614231 index, array_len));
14527 return ira->codegen->builtin_types.entry_invalid;
14232 return ira->codegen->invalid_instruction;
1452814233 }
1452914234 safety_check_on = false;
1453014235 }
......@@ -14556,14 +14261,15 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1455614261 ConstExprValue *array_ptr_val = ir_const_ptr_pointee(ira, orig_array_ptr_val,
1455714262 elem_ptr_instruction->base.source_node);
1455814263 if (array_ptr_val == nullptr)
14559 return ira->codegen->builtin_types.entry_invalid;
14264 return ira->codegen->invalid_instruction;
1456014265
1456114266 if (array_ptr_val->special != ConstValSpecialRuntime &&
1456214267 (array_type->id != ZigTypeIdPointer ||
1456314268 array_ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr))
1456414269 {
1456514270 if (array_type->id == ZigTypeIdPointer) {
14566 ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
14271 IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
14272 ConstExprValue *out_val = &result->value;
1456714273 out_val->data.x_ptr.mut = array_ptr_val->data.x_ptr.mut;
1456814274 size_t new_index;
1456914275 size_t mem_size;
......@@ -14608,26 +14314,26 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1460814314 if (new_index >= mem_size) {
1460914315 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1461014316 buf_sprintf("index %" ZIG_PRI_u64 " outside pointer of size %" ZIG_PRI_usize "", index, old_size));
14611 return ira->codegen->builtin_types.entry_invalid;
14317 return ira->codegen->invalid_instruction;
1461214318 }
14613 return return_type;
14319 return result;
1461414320 } else if (is_slice(array_type)) {
1461514321 ConstExprValue *ptr_field = &array_ptr_val->data.x_struct.fields[slice_ptr_index];
1461614322 if (ptr_field->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
1461714323 IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope, elem_ptr_instruction->base.source_node,
1461814324 array_ptr, casted_elem_index, false, elem_ptr_instruction->ptr_len);
1461914325 result->value.type = return_type;
14620 ir_link_new_instruction(result, &elem_ptr_instruction->base);
14621 return return_type;
14326 return result;
1462214327 }
1462314328 ConstExprValue *len_field = &array_ptr_val->data.x_struct.fields[slice_len_index];
14624 ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
14329 IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
14330 ConstExprValue *out_val = &result->value;
1462514331 uint64_t slice_len = bigint_as_unsigned(&len_field->data.x_bigint);
1462614332 if (index >= slice_len) {
1462714333 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
1462814334 buf_sprintf("index %" ZIG_PRI_u64 " outside slice of size %" ZIG_PRI_u64,
1462914335 index, slice_len));
14630 return ira->codegen->builtin_types.entry_invalid;
14336 return ira->codegen->invalid_instruction;
1463114337 }
1463214338 out_val->data.x_ptr.mut = ptr_field->data.x_ptr.mut;
1463314339 switch (ptr_field->data.x_ptr.special) {
......@@ -14658,14 +14364,15 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1465814364 case ConstPtrSpecialFunction:
1465914365 zig_panic("TODO elem ptr on a slice that was ptrcast from a function");
1466014366 }
14661 return return_type;
14367 return result;
1466214368 } else if (array_type->id == ZigTypeIdArray) {
14663 ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
14369 IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
14370 ConstExprValue *out_val = &result->value;
1466414371 out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
1466514372 out_val->data.x_ptr.mut = orig_array_ptr_val->data.x_ptr.mut;
1466614373 out_val->data.x_ptr.data.base_array.array_val = array_ptr_val;
1466714374 out_val->data.x_ptr.data.base_array.elem_index = index;
14668 return return_type;
14375 return result;
1466914376 } else {
1467014377 zig_unreachable();
1467114378 }
......@@ -14678,7 +14385,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1467814385 ir_add_error(ira, elem_index,
1467914386 buf_sprintf("values of type '%s' must be comptime known, but index value is runtime known",
1468014387 buf_ptr(&return_type->data.pointer.child_type->name)));
14681 return ira->codegen->builtin_types.entry_invalid;
14388 return ira->codegen->invalid_instruction;
1468214389 }
1468314390 if (ptr_align < abi_align) {
1468414391 if (elem_size >= ptr_align && elem_size % ptr_align == 0) {
......@@ -14695,8 +14402,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
1469514402 IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope, elem_ptr_instruction->base.source_node,
1469614403 array_ptr, casted_elem_index, safety_check_on, elem_ptr_instruction->ptr_len);
1469714404 result->value.type = return_type;
14698 ir_link_new_instruction(result, &elem_ptr_instruction->base);
14699 return return_type;
14405 return result;
1470014406}
1470114407
1470214408static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
......@@ -14776,13 +14482,12 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
1477614482 is_const, is_volatile, PtrLenSingle, align_bytes,
1477714483 (uint32_t)(ptr_bit_offset + field->bit_offset_in_host),
1477814484 (uint32_t)host_int_bytes_for_result_type);
14779 IrInstruction *result = ir_get_const(ira, source_instr);
14485 IrInstruction *result = ir_const(ira, source_instr, ptr_type);
1478014486 ConstExprValue *const_val = &result->value;
1478114487 const_val->data.x_ptr.special = ConstPtrSpecialBaseStruct;
1478214488 const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
1478314489 const_val->data.x_ptr.data.base_struct.struct_val = struct_val;
1478414490 const_val->data.x_ptr.data.base_struct.field_index = field->src_index;
14785 const_val->type = ptr_type;
1478614491 return result;
1478714492 }
1478814493 }
......@@ -14840,12 +14545,11 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
1484014545 ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type,
1484114546 is_const, is_volatile, PtrLenSingle, 0, 0, 0);
1484214547
14843 IrInstruction *result = ir_get_const(ira, source_instr);
14548 IrInstruction *result = ir_const(ira, source_instr, ptr_type);
1484414549 ConstExprValue *const_val = &result->value;
1484514550 const_val->data.x_ptr.special = ConstPtrSpecialRef;
1484614551 const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
1484714552 const_val->data.x_ptr.data.ref.pointee = payload_val;
14848 const_val->type = ptr_type;
1484914553 return result;
1485014554 }
1485114555 }
......@@ -14882,11 +14586,11 @@ static void add_link_lib_symbol(IrAnalyze *ira, Buf *lib_name, Buf *symbol_name,
1488214586}
1488314587
1488414588
14885static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) {
14589static IrInstruction *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) {
1488614590 bool pointer_only = false;
1488714591 resolve_top_level_decl(ira->codegen, tld, pointer_only, source_instruction->source_node);
1488814592 if (tld->resolution == TldResolutionInvalid)
14889 return ira->codegen->builtin_types.entry_invalid;
14593 return ira->codegen->invalid_instruction;
1489014594
1489114595 switch (tld->id) {
1489214596 case TldIdContainer:
......@@ -14900,7 +14604,7 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
1490014604 add_link_lib_symbol(ira, tld_var->extern_lib_name, &var->name, source_instruction->source_node);
1490114605 }
1490214606
14903 return ir_analyze_var_ptr(ira, source_instruction, var);
14607 return ir_get_var_ptr(ira, source_instruction, var);
1490414608 }
1490514609 case TldIdFn:
1490614610 {
......@@ -14909,7 +14613,7 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
1490914613 assert(fn_entry->type_entry);
1491014614
1491114615 if (type_is_invalid(fn_entry->type_entry))
14912 return ira->codegen->builtin_types.entry_invalid;
14616 return ira->codegen->invalid_instruction;
1491314617
1491414618 // TODO instead of allocating this every time, put it in the tld value and we can reference
1491514619 // the same one every time
......@@ -14926,8 +14630,8 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
1492614630
1492714631 bool ptr_is_const = true;
1492814632 bool ptr_is_volatile = false;
14929 return ir_analyze_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry,
14930 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14633 return ir_get_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry,
14634 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1493114635 }
1493214636 }
1493314637 zig_unreachable();
......@@ -14944,45 +14648,43 @@ static ErrorTableEntry *find_err_table_entry(ZigType *err_set_type, Buf *field_n
1494414648 return nullptr;
1494514649}
1494614650
14947static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
14651static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
1494814652 Error err;
14949 IrInstruction *container_ptr = field_ptr_instruction->container_ptr->other;
14653 IrInstruction *container_ptr = field_ptr_instruction->container_ptr->child;
1495014654 if (type_is_invalid(container_ptr->value.type))
14951 return ira->codegen->builtin_types.entry_invalid;
14655 return ira->codegen->invalid_instruction;
1495214656
1495314657 if (container_ptr->value.type->id != ZigTypeIdPointer) {
1495414658 ir_add_error_node(ira, field_ptr_instruction->base.source_node,
1495514659 buf_sprintf("attempt to dereference non-pointer type '%s'",
1495614660 buf_ptr(&container_ptr->value.type->name)));
14957 return ira->codegen->builtin_types.entry_invalid;
14661 return ira->codegen->invalid_instruction;
1495814662 }
1495914663 ZigType *container_type = container_ptr->value.type->data.pointer.child_type;
1496014664
1496114665 Buf *field_name = field_ptr_instruction->field_name_buffer;
1496214666 if (!field_name) {
14963 IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->other;
14667 IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->child;
1496414668 field_name = ir_resolve_str(ira, field_name_expr);
1496514669 if (!field_name)
14966 return ira->codegen->builtin_types.entry_invalid;
14670 return ira->codegen->invalid_instruction;
1496714671 }
1496814672
1496914673
1497014674 AstNode *source_node = field_ptr_instruction->base.source_node;
1497114675
1497214676 if (type_is_invalid(container_type)) {
14973 return container_type;
14677 return ira->codegen->invalid_instruction;
1497414678 } else if (is_container_ref(container_type)) {
1497514679 assert(container_ptr->value.type->id == ZigTypeIdPointer);
1497614680 if (container_type->id == ZigTypeIdPointer) {
1497714681 ZigType *bare_type = container_ref_type(container_type);
1497814682 IrInstruction *container_child = ir_get_deref(ira, &field_ptr_instruction->base, container_ptr);
1497914683 IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_child, bare_type);
14980 ir_link_new_instruction(result, &field_ptr_instruction->base);
14981 return result->value.type;
14684 return result;
1498214685 } else {
1498314686 IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_ptr, container_type);
14984 ir_link_new_instruction(result, &field_ptr_instruction->base);
14985 return result->value.type;
14687 return result;
1498614688 }
1498714689 } else if (is_array_ref(container_type)) {
1498814690 if (buf_eql_str(field_name, "len")) {
......@@ -14996,23 +14698,23 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1499614698 ZigType *usize = ira->codegen->builtin_types.entry_usize;
1499714699 bool ptr_is_const = true;
1499814700 bool ptr_is_volatile = false;
14999 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
15000 usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14701 return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
14702 usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1500114703 } else {
1500214704 ir_add_error_node(ira, source_node,
1500314705 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
1500414706 buf_ptr(&container_type->name)));
15005 return ira->codegen->builtin_types.entry_invalid;
14707 return ira->codegen->invalid_instruction;
1500614708 }
1500714709 } else if (container_type->id == ZigTypeIdArgTuple) {
1500814710 ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
1500914711 if (!container_ptr_val)
15010 return ira->codegen->builtin_types.entry_invalid;
14712 return ira->codegen->invalid_instruction;
1501114713
1501214714 assert(container_ptr->value.type->id == ZigTypeIdPointer);
1501314715 ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
1501414716 if (child_val == nullptr)
15015 return ira->codegen->builtin_types.entry_invalid;
14717 return ira->codegen->invalid_instruction;
1501614718
1501714719 if (buf_eql_str(field_name, "len")) {
1501814720 ConstExprValue *len_val = create_const_vals(1);
......@@ -15022,27 +14724,27 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1502214724 ZigType *usize = ira->codegen->builtin_types.entry_usize;
1502314725 bool ptr_is_const = true;
1502414726 bool ptr_is_volatile = false;
15025 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
15026 usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14727 return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
14728 usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1502714729 } else {
1502814730 ir_add_error_node(ira, source_node,
1502914731 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
1503014732 buf_ptr(&container_type->name)));
15031 return ira->codegen->builtin_types.entry_invalid;
14733 return ira->codegen->invalid_instruction;
1503214734 }
1503314735 } else if (container_type->id == ZigTypeIdMetaType) {
1503414736 ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
1503514737 if (!container_ptr_val)
15036 return ira->codegen->builtin_types.entry_invalid;
14738 return ira->codegen->invalid_instruction;
1503714739
1503814740 assert(container_ptr->value.type->id == ZigTypeIdPointer);
1503914741 ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
1504014742 if (child_val == nullptr)
15041 return ira->codegen->builtin_types.entry_invalid;
14743 return ira->codegen->invalid_instruction;
1504214744 ZigType *child_type = child_val->data.x_type;
1504314745
1504414746 if (type_is_invalid(child_type)) {
15045 return ira->codegen->builtin_types.entry_invalid;
14747 return ira->codegen->invalid_instruction;
1504614748 } else if (is_container(child_type)) {
1504714749 if (is_slice(child_type) && buf_eql_str(field_name, "Child")) {
1504814750 bool ptr_is_const = true;
......@@ -15050,22 +14752,22 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1505014752 TypeStructField *ptr_field = &child_type->data.structure.fields[slice_ptr_index];
1505114753 assert(ptr_field->type_entry->id == ZigTypeIdPointer);
1505214754 ZigType *child_type = ptr_field->type_entry->data.pointer.child_type;
15053 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14755 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1505414756 create_const_type(ira->codegen, child_type),
1505514757 ira->codegen->builtin_types.entry_type,
15056 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14758 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1505714759 }
1505814760 if (child_type->id == ZigTypeIdEnum) {
1505914761 if ((err = ensure_complete_type(ira->codegen, child_type)))
15060 return ira->codegen->builtin_types.entry_invalid;
14762 return ira->codegen->invalid_instruction;
1506114763
1506214764 TypeEnumField *field = find_enum_type_field(child_type, field_name);
1506314765 if (field) {
1506414766 bool ptr_is_const = true;
1506514767 bool ptr_is_volatile = false;
15066 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14768 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1506714769 create_const_enum(child_type, &field->value), child_type,
15068 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14770 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1506914771 }
1507014772 }
1507114773 ScopeDecls *container_scope = get_container_scope(child_type);
......@@ -15081,21 +14783,21 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1508114783 child_type->data.unionation.decl_node->data.container_decl.auto_enum))
1508214784 {
1508314785 if ((err = ensure_complete_type(ira->codegen, child_type)))
15084 return ira->codegen->builtin_types.entry_invalid;
14786 return ira->codegen->invalid_instruction;
1508514787 TypeUnionField *field = find_union_type_field(child_type, field_name);
1508614788 if (field) {
1508714789 ZigType *enum_type = child_type->data.unionation.tag_type;
1508814790 bool ptr_is_const = true;
1508914791 bool ptr_is_volatile = false;
15090 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14792 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1509114793 create_const_enum(enum_type, &field->enum_field->value), enum_type,
15092 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14794 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1509314795 }
1509414796 }
1509514797 ir_add_error(ira, &field_ptr_instruction->base,
1509614798 buf_sprintf("container '%s' has no member called '%s'",
1509714799 buf_ptr(&child_type->name), buf_ptr(field_name)));
15098 return ira->codegen->builtin_types.entry_invalid;
14800 return ira->codegen->invalid_instruction;
1509914801 } else if (child_type->id == ZigTypeIdErrorSet) {
1510014802 ErrorTableEntry *err_entry;
1510114803 ZigType *err_set_type;
......@@ -15123,13 +14825,13 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1512314825 err_set_type = err_entry->set_with_only_this_in_it;
1512414826 } else {
1512514827 if (!resolve_inferred_error_set(ira->codegen, child_type, field_ptr_instruction->base.source_node)) {
15126 return ira->codegen->builtin_types.entry_invalid;
14828 return ira->codegen->invalid_instruction;
1512714829 }
1512814830 err_entry = find_err_table_entry(child_type, field_name);
1512914831 if (err_entry == nullptr) {
1513014832 ir_add_error(ira, &field_ptr_instruction->base,
1513114833 buf_sprintf("no error named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&child_type->name)));
15132 return ira->codegen->builtin_types.entry_invalid;
14834 return ira->codegen->invalid_instruction;
1513314835 }
1513414836 err_set_type = child_type;
1513514837 }
......@@ -15140,128 +14842,128 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1514014842
1514114843 bool ptr_is_const = true;
1514214844 bool ptr_is_volatile = false;
15143 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, const_val,
15144 err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14845 return ir_get_const_ptr(ira, &field_ptr_instruction->base, const_val,
14846 err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1514514847 } else if (child_type->id == ZigTypeIdInt) {
1514614848 if (buf_eql_str(field_name, "bit_count")) {
1514714849 bool ptr_is_const = true;
1514814850 bool ptr_is_volatile = false;
15149 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14851 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1515014852 create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
1515114853 child_type->data.integral.bit_count, false),
1515214854 ira->codegen->builtin_types.entry_num_lit_int,
15153 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14855 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1515414856 } else if (buf_eql_str(field_name, "is_signed")) {
1515514857 bool ptr_is_const = true;
1515614858 bool ptr_is_volatile = false;
15157 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14859 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1515814860 create_const_bool(ira->codegen, child_type->data.integral.is_signed),
1515914861 ira->codegen->builtin_types.entry_bool,
15160 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14862 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1516114863 } else {
1516214864 ir_add_error(ira, &field_ptr_instruction->base,
1516314865 buf_sprintf("type '%s' has no member called '%s'",
1516414866 buf_ptr(&child_type->name), buf_ptr(field_name)));
15165 return ira->codegen->builtin_types.entry_invalid;
14867 return ira->codegen->invalid_instruction;
1516614868 }
1516714869 } else if (child_type->id == ZigTypeIdFloat) {
1516814870 if (buf_eql_str(field_name, "bit_count")) {
1516914871 bool ptr_is_const = true;
1517014872 bool ptr_is_volatile = false;
15171 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14873 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1517214874 create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
1517314875 child_type->data.floating.bit_count, false),
1517414876 ira->codegen->builtin_types.entry_num_lit_int,
15175 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14877 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1517614878 } else {
1517714879 ir_add_error(ira, &field_ptr_instruction->base,
1517814880 buf_sprintf("type '%s' has no member called '%s'",
1517914881 buf_ptr(&child_type->name), buf_ptr(field_name)));
15180 return ira->codegen->builtin_types.entry_invalid;
14882 return ira->codegen->invalid_instruction;
1518114883 }
1518214884 } else if (child_type->id == ZigTypeIdPointer) {
1518314885 if (buf_eql_str(field_name, "Child")) {
1518414886 bool ptr_is_const = true;
1518514887 bool ptr_is_volatile = false;
15186 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14888 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1518714889 create_const_type(ira->codegen, child_type->data.pointer.child_type),
1518814890 ira->codegen->builtin_types.entry_type,
15189 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14891 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1519014892 } else if (buf_eql_str(field_name, "alignment")) {
1519114893 bool ptr_is_const = true;
1519214894 bool ptr_is_volatile = false;
1519314895 if ((err = type_resolve(ira->codegen, child_type->data.pointer.child_type,
1519414896 ResolveStatusAlignmentKnown)))
1519514897 {
15196 return ira->codegen->builtin_types.entry_invalid;
14898 return ira->codegen->invalid_instruction;
1519714899 }
15198 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14900 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1519914901 create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
1520014902 get_ptr_align(ira->codegen, child_type), false),
1520114903 ira->codegen->builtin_types.entry_num_lit_int,
15202 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14904 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1520314905 } else {
1520414906 ir_add_error(ira, &field_ptr_instruction->base,
1520514907 buf_sprintf("type '%s' has no member called '%s'",
1520614908 buf_ptr(&child_type->name), buf_ptr(field_name)));
15207 return ira->codegen->builtin_types.entry_invalid;
14909 return ira->codegen->invalid_instruction;
1520814910 }
1520914911 } else if (child_type->id == ZigTypeIdArray) {
1521014912 if (buf_eql_str(field_name, "Child")) {
1521114913 bool ptr_is_const = true;
1521214914 bool ptr_is_volatile = false;
15213 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14915 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1521414916 create_const_type(ira->codegen, child_type->data.array.child_type),
1521514917 ira->codegen->builtin_types.entry_type,
15216 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14918 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1521714919 } else if (buf_eql_str(field_name, "len")) {
1521814920 bool ptr_is_const = true;
1521914921 bool ptr_is_volatile = false;
15220 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14922 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1522114923 create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
1522214924 child_type->data.array.len, false),
1522314925 ira->codegen->builtin_types.entry_num_lit_int,
15224 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14926 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1522514927 } else {
1522614928 ir_add_error(ira, &field_ptr_instruction->base,
1522714929 buf_sprintf("type '%s' has no member called '%s'",
1522814930 buf_ptr(&child_type->name), buf_ptr(field_name)));
15229 return ira->codegen->builtin_types.entry_invalid;
14931 return ira->codegen->invalid_instruction;
1523014932 }
1523114933 } else if (child_type->id == ZigTypeIdErrorUnion) {
1523214934 if (buf_eql_str(field_name, "Payload")) {
1523314935 bool ptr_is_const = true;
1523414936 bool ptr_is_volatile = false;
15235 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14937 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1523614938 create_const_type(ira->codegen, child_type->data.error_union.payload_type),
1523714939 ira->codegen->builtin_types.entry_type,
15238 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14940 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1523914941 } else if (buf_eql_str(field_name, "ErrorSet")) {
1524014942 bool ptr_is_const = true;
1524114943 bool ptr_is_volatile = false;
15242 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14944 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1524314945 create_const_type(ira->codegen, child_type->data.error_union.err_set_type),
1524414946 ira->codegen->builtin_types.entry_type,
15245 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14947 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1524614948 } else {
1524714949 ir_add_error(ira, &field_ptr_instruction->base,
1524814950 buf_sprintf("type '%s' has no member called '%s'",
1524914951 buf_ptr(&child_type->name), buf_ptr(field_name)));
15250 return ira->codegen->builtin_types.entry_invalid;
14952 return ira->codegen->invalid_instruction;
1525114953 }
1525214954 } else if (child_type->id == ZigTypeIdOptional) {
1525314955 if (buf_eql_str(field_name, "Child")) {
1525414956 bool ptr_is_const = true;
1525514957 bool ptr_is_volatile = false;
15256 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14958 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1525714959 create_const_type(ira->codegen, child_type->data.maybe.child_type),
1525814960 ira->codegen->builtin_types.entry_type,
15259 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14961 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1526014962 } else {
1526114963 ir_add_error(ira, &field_ptr_instruction->base,
1526214964 buf_sprintf("type '%s' has no member called '%s'",
1526314965 buf_ptr(&child_type->name), buf_ptr(field_name)));
15264 return ira->codegen->builtin_types.entry_invalid;
14966 return ira->codegen->invalid_instruction;
1526514967 }
1526614968 } else if (child_type->id == ZigTypeIdFn) {
1526714969 if (buf_eql_str(field_name, "ReturnType")) {
......@@ -15271,50 +14973,50 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1527114973
1527214974 ir_add_error(ira, &field_ptr_instruction->base,
1527314975 buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
15274 return ira->codegen->builtin_types.entry_invalid;
14976 return ira->codegen->invalid_instruction;
1527514977 }
1527614978
1527714979 bool ptr_is_const = true;
1527814980 bool ptr_is_volatile = false;
15279 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14981 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1528014982 create_const_type(ira->codegen, child_type->data.fn.fn_type_id.return_type),
1528114983 ira->codegen->builtin_types.entry_type,
15282 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14984 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1528314985 } else if (buf_eql_str(field_name, "is_var_args")) {
1528414986 bool ptr_is_const = true;
1528514987 bool ptr_is_volatile = false;
15286 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14988 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1528714989 create_const_bool(ira->codegen, child_type->data.fn.fn_type_id.is_var_args),
1528814990 ira->codegen->builtin_types.entry_bool,
15289 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14991 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1529014992 } else if (buf_eql_str(field_name, "arg_count")) {
1529114993 bool ptr_is_const = true;
1529214994 bool ptr_is_volatile = false;
15293 return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
14995 return ir_get_const_ptr(ira, &field_ptr_instruction->base,
1529414996 create_const_usize(ira->codegen, child_type->data.fn.fn_type_id.param_count),
1529514997 ira->codegen->builtin_types.entry_usize,
15296 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
14998 ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
1529714999 } else {
1529815000 ir_add_error(ira, &field_ptr_instruction->base,
1529915001 buf_sprintf("type '%s' has no member called '%s'",
1530015002 buf_ptr(&child_type->name), buf_ptr(field_name)));
15301 return ira->codegen->builtin_types.entry_invalid;
15003 return ira->codegen->invalid_instruction;
1530215004 }
1530315005 } else {
1530415006 ir_add_error(ira, &field_ptr_instruction->base,
1530515007 buf_sprintf("type '%s' does not support field access", buf_ptr(&child_type->name)));
15306 return ira->codegen->builtin_types.entry_invalid;
15008 return ira->codegen->invalid_instruction;
1530715009 }
1530815010 } else if (container_type->id == ZigTypeIdNamespace) {
1530915011 assert(container_ptr->value.type->id == ZigTypeIdPointer);
1531015012 ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
1531115013 if (!container_ptr_val)
15312 return ira->codegen->builtin_types.entry_invalid;
15014 return ira->codegen->invalid_instruction;
1531315015
1531415016 ConstExprValue *namespace_val = ir_const_ptr_pointee(ira, container_ptr_val,
1531515017 field_ptr_instruction->base.source_node);
1531615018 if (namespace_val == nullptr)
15317 return ira->codegen->builtin_types.entry_invalid;
15019 return ira->codegen->invalid_instruction;
1531815020 assert(namespace_val->special == ConstValSpecialStatic);
1531915021
1532015022 ImportTableEntry *namespace_import = namespace_val->data.x_import;
......@@ -15327,78 +15029,74 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
1532715029 ErrorMsg *msg = ir_add_error_node(ira, source_node,
1532815030 buf_sprintf("'%s' is private", buf_ptr(field_name)));
1532915031 add_error_note(ira->codegen, msg, tld->source_node, buf_sprintf("declared here"));
15330 return ira->codegen->builtin_types.entry_invalid;
15032 return ira->codegen->invalid_instruction;
1533115033 }
1533215034 return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
1533315035 } else {
1533415036 const char *import_name = namespace_import->path ? buf_ptr(namespace_import->path) : "(C import)";
1533515037 ir_add_error_node(ira, source_node,
1533615038 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name), import_name));
15337 return ira->codegen->builtin_types.entry_invalid;
15039 return ira->codegen->invalid_instruction;
1533815040 }
1533915041 } else {
1534015042 ir_add_error_node(ira, field_ptr_instruction->base.source_node,
1534115043 buf_sprintf("type '%s' does not support field access", buf_ptr(&container_type->name)));
15342 return ira->codegen->builtin_types.entry_invalid;
15044 return ira->codegen->invalid_instruction;
1534315045 }
1534415046}
1534515047
15346static ZigType *ir_analyze_instruction_load_ptr(IrAnalyze *ira, IrInstructionLoadPtr *load_ptr_instruction) {
15347 IrInstruction *ptr = load_ptr_instruction->ptr->other;
15048static IrInstruction *ir_analyze_instruction_load_ptr(IrAnalyze *ira, IrInstructionLoadPtr *load_ptr_instruction) {
15049 IrInstruction *ptr = load_ptr_instruction->ptr->child;
1534815050 if (type_is_invalid(ptr->value.type))
15349 return ira->codegen->builtin_types.entry_invalid;
15350
15351 IrInstruction *result = ir_get_deref(ira, &load_ptr_instruction->base, ptr);
15352 ir_link_new_instruction(result, &load_ptr_instruction->base);
15353 assert(result->value.type);
15354 return result->value.type;
15051 return ira->codegen->invalid_instruction;
15052 return ir_get_deref(ira, &load_ptr_instruction->base, ptr);
1535515053}
1535615054
15357static ZigType *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionStorePtr *store_ptr_instruction) {
15358 IrInstruction *ptr = store_ptr_instruction->ptr->other;
15055static IrInstruction *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionStorePtr *store_ptr_instruction) {
15056 IrInstruction *ptr = store_ptr_instruction->ptr->child;
1535915057 if (type_is_invalid(ptr->value.type))
15360 return ptr->value.type;
15058 return ira->codegen->invalid_instruction;
1536115059
15362 IrInstruction *value = store_ptr_instruction->value->other;
15060 IrInstruction *value = store_ptr_instruction->value->child;
1536315061 if (type_is_invalid(value->value.type))
15364 return value->value.type;
15062 return ira->codegen->invalid_instruction;
1536515063
1536615064 if (ptr->value.type->id != ZigTypeIdPointer) {
1536715065 ir_add_error(ira, ptr,
1536815066 buf_sprintf("attempt to dereference non pointer type '%s'", buf_ptr(&ptr->value.type->name)));
15369 return ira->codegen->builtin_types.entry_invalid;
15067 return ira->codegen->invalid_instruction;
1537015068 }
1537115069
1537215070 if (ptr->value.data.x_ptr.special == ConstPtrSpecialDiscard) {
15373 return ir_analyze_void(ira, &store_ptr_instruction->base);
15071 return ir_const_void(ira, &store_ptr_instruction->base);
1537415072 }
1537515073
1537615074 if (ptr->value.type->data.pointer.is_const && !store_ptr_instruction->base.is_gen) {
1537715075 ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
15378 return ira->codegen->builtin_types.entry_invalid;
15076 return ira->codegen->invalid_instruction;
1537915077 }
1538015078
1538115079 ZigType *child_type = ptr->value.type->data.pointer.child_type;
1538215080 IrInstruction *casted_value = ir_implicit_cast(ira, value, child_type);
1538315081 if (casted_value == ira->codegen->invalid_instruction)
15384 return ira->codegen->builtin_types.entry_invalid;
15082 return ira->codegen->invalid_instruction;
1538515083
1538615084 if (instr_is_comptime(ptr) && ptr->value.data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
1538715085 if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst) {
1538815086 ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
15389 return ira->codegen->builtin_types.entry_invalid;
15087 return ira->codegen->invalid_instruction;
1539015088 }
1539115089 if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeVar) {
1539215090 if (instr_is_comptime(casted_value)) {
1539315091 ConstExprValue *dest_val = ir_const_ptr_pointee(ira, &ptr->value, store_ptr_instruction->base.source_node);
1539415092 if (dest_val == nullptr)
15395 return ira->codegen->builtin_types.entry_invalid;
15093 return ira->codegen->invalid_instruction;
1539615094 if (dest_val->special != ConstValSpecialRuntime) {
1539715095 *dest_val = casted_value->value;
1539815096 if (!ira->new_irb.current_basic_block->must_be_comptime_source_instr) {
1539915097 ira->new_irb.current_basic_block->must_be_comptime_source_instr = &store_ptr_instruction->base;
1540015098 }
15401 return ir_analyze_void(ira, &store_ptr_instruction->base);
15099 return ir_const_void(ira, &store_ptr_instruction->base);
1540215100 }
1540315101 }
1540415102 ir_add_error(ira, &store_ptr_instruction->base,
......@@ -15406,19 +15104,22 @@ static ZigType *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionSt
1540615104 ConstExprValue *dest_val = const_ptr_pointee_unchecked(ira->codegen, &ptr->value);
1540715105 dest_val->type = ira->codegen->builtin_types.entry_invalid;
1540815106
15409 return ira->codegen->builtin_types.entry_invalid;
15107 return ira->codegen->invalid_instruction;
1541015108 }
1541115109 }
1541215110
15413 ir_build_store_ptr_from(&ira->new_irb, &store_ptr_instruction->base, ptr, casted_value);
15414 return ira->codegen->builtin_types.entry_void;
15111 IrInstruction *result = ir_build_store_ptr(&ira->new_irb,
15112 store_ptr_instruction->base.scope, store_ptr_instruction->base.source_node,
15113 ptr, casted_value);
15114 result->value.type = ira->codegen->builtin_types.entry_void;
15115 return result;
1541515116}
1541615117
15417static ZigType *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeOf *typeof_instruction) {
15418 IrInstruction *expr_value = typeof_instruction->value->other;
15118static IrInstruction *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeOf *typeof_instruction) {
15119 IrInstruction *expr_value = typeof_instruction->value->child;
1541915120 ZigType *type_entry = expr_value->value.type;
1542015121 if (type_is_invalid(type_entry))
15421 return ira->codegen->builtin_types.entry_invalid;
15122 return ira->codegen->invalid_instruction;
1542215123 switch (type_entry->id) {
1542315124 case ZigTypeIdInvalid:
1542415125 zig_unreachable(); // handled above
......@@ -15446,24 +15147,19 @@ static ZigType *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeO
1544615147 case ZigTypeIdArgTuple:
1544715148 case ZigTypeIdOpaque:
1544815149 case ZigTypeIdPromise:
15449 {
15450 ConstExprValue *out_val = ir_build_const_from(ira, &typeof_instruction->base);
15451 out_val->data.x_type = type_entry;
15452
15453 return ira->codegen->builtin_types.entry_type;
15454 }
15150 return ir_const_type(ira, &typeof_instruction->base, type_entry);
1545515151 }
1545615152
1545715153 zig_unreachable();
1545815154}
1545915155
15460static ZigType *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
15156static IrInstruction *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
1546115157 IrInstructionToPtrType *to_ptr_type_instruction)
1546215158{
15463 IrInstruction *value = to_ptr_type_instruction->value->other;
15159 IrInstruction *value = to_ptr_type_instruction->value->child;
1546415160 ZigType *type_entry = value->value.type;
1546515161 if (type_is_invalid(type_entry))
15466 return type_entry;
15162 return ira->codegen->invalid_instruction;
1546715163
1546815164 ZigType *ptr_type;
1546915165 if (type_entry->id == ZigTypeIdArray) {
......@@ -15473,76 +15169,69 @@ static ZigType *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
1547315169 } else if (type_entry->id == ZigTypeIdArgTuple) {
1547415170 ConstExprValue *arg_tuple_val = ir_resolve_const(ira, value, UndefBad);
1547515171 if (!arg_tuple_val)
15476 return ira->codegen->builtin_types.entry_invalid;
15172 return ira->codegen->invalid_instruction;
1547715173 zig_panic("TODO for loop on var args");
1547815174 } else {
1547915175 ir_add_error_node(ira, to_ptr_type_instruction->base.source_node,
1548015176 buf_sprintf("expected array type, found '%s'", buf_ptr(&type_entry->name)));
15481 return ira->codegen->builtin_types.entry_invalid;
15177 return ira->codegen->invalid_instruction;
1548215178 }
1548315179
15484 ConstExprValue *out_val = ir_build_const_from(ira, &to_ptr_type_instruction->base);
15485 out_val->data.x_type = ptr_type;
15486 return ira->codegen->builtin_types.entry_type;
15180 return ir_const_type(ira, &to_ptr_type_instruction->base, ptr_type);
1548715181}
1548815182
15489static ZigType *ir_analyze_instruction_ptr_type_child(IrAnalyze *ira,
15183static IrInstruction *ir_analyze_instruction_ptr_type_child(IrAnalyze *ira,
1549015184 IrInstructionPtrTypeChild *ptr_type_child_instruction)
1549115185{
15492 IrInstruction *type_value = ptr_type_child_instruction->value->other;
15186 IrInstruction *type_value = ptr_type_child_instruction->value->child;
1549315187 ZigType *type_entry = ir_resolve_type(ira, type_value);
1549415188 if (type_is_invalid(type_entry))
15495 return type_entry;
15189 return ira->codegen->invalid_instruction;
1549615190
1549715191 if (type_entry->id != ZigTypeIdPointer) {
1549815192 ir_add_error_node(ira, ptr_type_child_instruction->base.source_node,
1549915193 buf_sprintf("expected pointer type, found '%s'", buf_ptr(&type_entry->name)));
15500 return ira->codegen->builtin_types.entry_invalid;
15194 return ira->codegen->invalid_instruction;
1550115195 }
1550215196
15503 ConstExprValue *out_val = ir_build_const_from(ira, &ptr_type_child_instruction->base);
15504 out_val->data.x_type = type_entry->data.pointer.child_type;
15505 return ira->codegen->builtin_types.entry_type;
15197 return ir_const_type(ira, &ptr_type_child_instruction->base, type_entry->data.pointer.child_type);
1550615198}
1550715199
15508static ZigType *ir_analyze_instruction_set_cold(IrAnalyze *ira, IrInstructionSetCold *instruction) {
15200static IrInstruction *ir_analyze_instruction_set_cold(IrAnalyze *ira, IrInstructionSetCold *instruction) {
1550915201 if (ira->new_irb.exec->is_inline) {
1551015202 // ignore setCold when running functions at compile time
15511 ir_build_const_from(ira, &instruction->base);
15512 return ira->codegen->builtin_types.entry_void;
15203 return ir_const_void(ira, &instruction->base);
1551315204 }
1551415205
15515 IrInstruction *is_cold_value = instruction->is_cold->other;
15206 IrInstruction *is_cold_value = instruction->is_cold->child;
1551615207 bool want_cold;
1551715208 if (!ir_resolve_bool(ira, is_cold_value, &want_cold))
15518 return ira->codegen->builtin_types.entry_invalid;
15209 return ira->codegen->invalid_instruction;
1551915210
1552015211 ZigFn *fn_entry = scope_fn_entry(instruction->base.scope);
1552115212 if (fn_entry == nullptr) {
1552215213 ir_add_error(ira, &instruction->base, buf_sprintf("@setCold outside function"));
15523 return ira->codegen->builtin_types.entry_invalid;
15214 return ira->codegen->invalid_instruction;
1552415215 }
1552515216
1552615217 if (fn_entry->set_cold_node != nullptr) {
1552715218 ErrorMsg *msg = ir_add_error(ira, &instruction->base, buf_sprintf("cold set twice in same function"));
1552815219 add_error_note(ira->codegen, msg, fn_entry->set_cold_node, buf_sprintf("first set here"));
15529 return ira->codegen->builtin_types.entry_invalid;
15220 return ira->codegen->invalid_instruction;
1553015221 }
1553115222
1553215223 fn_entry->set_cold_node = instruction->base.source_node;
1553315224 fn_entry->is_cold = want_cold;
1553415225
15535 ir_build_const_from(ira, &instruction->base);
15536 return ira->codegen->builtin_types.entry_void;
15226 return ir_const_void(ira, &instruction->base);
1553715227}
1553815228
15539static ZigType *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
15229static IrInstruction *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
1554015230 IrInstructionSetRuntimeSafety *set_runtime_safety_instruction)
1554115231{
1554215232 if (ira->new_irb.exec->is_inline) {
1554315233 // ignore setRuntimeSafety when running functions at compile time
15544 ir_build_const_from(ira, &set_runtime_safety_instruction->base);
15545 return ira->codegen->builtin_types.entry_void;
15234 return ir_const_void(ira, &set_runtime_safety_instruction->base);
1554615235 }
1554715236
1554815237 bool *safety_off_ptr;
......@@ -15574,32 +15263,30 @@ static ZigType *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
1557415263 }
1557515264 assert(scope != nullptr);
1557615265
15577 IrInstruction *safety_on_value = set_runtime_safety_instruction->safety_on->other;
15266 IrInstruction *safety_on_value = set_runtime_safety_instruction->safety_on->child;
1557815267 bool want_runtime_safety;
1557915268 if (!ir_resolve_bool(ira, safety_on_value, &want_runtime_safety))
15580 return ira->codegen->builtin_types.entry_invalid;
15269 return ira->codegen->invalid_instruction;
1558115270
1558215271 AstNode *source_node = set_runtime_safety_instruction->base.source_node;
1558315272 if (*safety_set_node_ptr) {
1558415273 ErrorMsg *msg = ir_add_error_node(ira, source_node,
1558515274 buf_sprintf("runtime safety set twice for same scope"));
1558615275 add_error_note(ira->codegen, msg, *safety_set_node_ptr, buf_sprintf("first set here"));
15587 return ira->codegen->builtin_types.entry_invalid;
15276 return ira->codegen->invalid_instruction;
1558815277 }
1558915278 *safety_set_node_ptr = source_node;
1559015279 *safety_off_ptr = !want_runtime_safety;
1559115280
15592 ir_build_const_from(ira, &set_runtime_safety_instruction->base);
15593 return ira->codegen->builtin_types.entry_void;
15281 return ir_const_void(ira, &set_runtime_safety_instruction->base);
1559415282}
1559515283
15596static ZigType *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
15284static IrInstruction *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
1559715285 IrInstructionSetFloatMode *instruction)
1559815286{
1559915287 if (ira->new_irb.exec->is_inline) {
1560015288 // ignore setFloatMode when running functions at compile time
15601 ir_build_const_from(ira, &instruction->base);
15602 return ira->codegen->builtin_types.entry_void;
15289 return ir_const_void(ira, &instruction->base);
1560315290 }
1560415291
1560515292 bool *fast_math_on_ptr;
......@@ -15631,38 +15318,37 @@ static ZigType *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
1563115318 }
1563215319 assert(scope != nullptr);
1563315320
15634 IrInstruction *float_mode_value = instruction->mode_value->other;
15321 IrInstruction *float_mode_value = instruction->mode_value->child;
1563515322 FloatMode float_mode_scalar;
1563615323 if (!ir_resolve_float_mode(ira, float_mode_value, &float_mode_scalar))
15637 return ira->codegen->builtin_types.entry_invalid;
15324 return ira->codegen->invalid_instruction;
1563815325
1563915326 AstNode *source_node = instruction->base.source_node;
1564015327 if (*fast_math_set_node_ptr) {
1564115328 ErrorMsg *msg = ir_add_error_node(ira, source_node,
1564215329 buf_sprintf("float mode set twice for same scope"));
1564315330 add_error_note(ira->codegen, msg, *fast_math_set_node_ptr, buf_sprintf("first set here"));
15644 return ira->codegen->builtin_types.entry_invalid;
15331 return ira->codegen->invalid_instruction;
1564515332 }
1564615333 *fast_math_set_node_ptr = source_node;
1564715334 *fast_math_on_ptr = (float_mode_scalar == FloatModeOptimized);
1564815335
15649 ir_build_const_from(ira, &instruction->base);
15650 return ira->codegen->builtin_types.entry_void;
15336 return ir_const_void(ira, &instruction->base);
1565115337}
1565215338
15653static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
15339static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
1565415340 IrInstructionSliceType *slice_type_instruction)
1565515341{
1565615342 Error err;
1565715343 uint32_t align_bytes = 0;
1565815344 if (slice_type_instruction->align_value != nullptr) {
15659 if (!ir_resolve_align(ira, slice_type_instruction->align_value->other, &align_bytes))
15660 return ira->codegen->builtin_types.entry_invalid;
15345 if (!ir_resolve_align(ira, slice_type_instruction->align_value->child, &align_bytes))
15346 return ira->codegen->invalid_instruction;
1566115347 }
1566215348
15663 ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->other);
15349 ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->child);
1566415350 if (type_is_invalid(child_type))
15665 return ira->codegen->builtin_types.entry_invalid;
15351 return ira->codegen->invalid_instruction;
1566615352
1566715353 bool is_const = slice_type_instruction->is_const;
1566815354 bool is_volatile = slice_type_instruction->is_volatile;
......@@ -15677,7 +15363,7 @@ static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
1567715363 case ZigTypeIdOpaque:
1567815364 ir_add_error_node(ira, slice_type_instruction->base.source_node,
1567915365 buf_sprintf("slice of type '%s' not allowed", buf_ptr(&child_type->name)));
15680 return ira->codegen->builtin_types.entry_invalid;
15366 return ira->codegen->invalid_instruction;
1568115367 case ZigTypeIdMetaType:
1568215368 case ZigTypeIdVoid:
1568315369 case ZigTypeIdBool:
......@@ -15699,19 +15385,17 @@ static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
1569915385 case ZigTypeIdPromise:
1570015386 {
1570115387 if ((err = type_resolve(ira->codegen, child_type, ResolveStatusZeroBitsKnown)))
15702 return ira->codegen->builtin_types.entry_invalid;
15388 return ira->codegen->invalid_instruction;
1570315389 ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
1570415390 is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0);
1570515391 ZigType *result_type = get_slice_type(ira->codegen, slice_ptr_type);
15706 ConstExprValue *out_val = ir_build_const_from(ira, &slice_type_instruction->base);
15707 out_val->data.x_type = result_type;
15708 return ira->codegen->builtin_types.entry_type;
15392 return ir_const_type(ira, &slice_type_instruction->base, result_type);
1570915393 }
1571015394 }
1571115395 zig_unreachable();
1571215396}
1571315397
15714static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm_instruction) {
15398static IrInstruction *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm_instruction) {
1571515399 assert(asm_instruction->base.source_node->type == NodeTypeAsmExpr);
1571615400
1571715401 AstNodeAsmExpr *asm_expr = &asm_instruction->base.source_node->data.asm_expr;
......@@ -15723,18 +15407,17 @@ static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm
1572315407 {
1572415408 ir_add_error(ira, &asm_instruction->base,
1572515409 buf_sprintf("global assembly cannot have inputs, outputs, or clobbers"));
15726 return ira->codegen->builtin_types.entry_invalid;
15410 return ira->codegen->invalid_instruction;
1572715411 }
1572815412
1572915413 buf_append_char(&ira->codegen->global_asm, '\n');
1573015414 buf_append_buf(&ira->codegen->global_asm, asm_expr->asm_template);
1573115415
15732 ir_build_const_from(ira, &asm_instruction->base);
15733 return ira->codegen->builtin_types.entry_void;
15416 return ir_const_void(ira, &asm_instruction->base);
1573415417 }
1573515418
1573615419 if (!ir_emit_global_runtime_side_effect(ira, &asm_instruction->base))
15737 return ira->codegen->builtin_types.entry_invalid;
15420 return ira->codegen->invalid_instruction;
1573815421
1573915422 // TODO validate the output types and variable types
1574015423
......@@ -15745,38 +15428,41 @@ static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm
1574515428 for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
1574615429 AsmOutput *asm_output = asm_expr->output_list.at(i);
1574715430 if (asm_output->return_type) {
15748 output_types[i] = asm_instruction->output_types[i]->other;
15431 output_types[i] = asm_instruction->output_types[i]->child;
1574915432 return_type = ir_resolve_type(ira, output_types[i]);
1575015433 if (type_is_invalid(return_type))
15751 return ira->codegen->builtin_types.entry_invalid;
15434 return ira->codegen->invalid_instruction;
1575215435 }
1575315436 }
1575415437
1575515438 for (size_t i = 0; i < asm_expr->input_list.length; i += 1) {
15756 input_list[i] = asm_instruction->input_list[i]->other;
15439 input_list[i] = asm_instruction->input_list[i]->child;
1575715440 if (type_is_invalid(input_list[i]->value.type))
15758 return ira->codegen->builtin_types.entry_invalid;
15441 return ira->codegen->invalid_instruction;
1575915442 }
1576015443
15761 ir_build_asm_from(&ira->new_irb, &asm_instruction->base, input_list, output_types,
15762 asm_instruction->output_vars, asm_instruction->return_count, asm_instruction->has_side_effects);
15763 return return_type;
15444 IrInstruction *result = ir_build_asm(&ira->new_irb,
15445 asm_instruction->base.scope, asm_instruction->base.source_node,
15446 input_list, output_types, asm_instruction->output_vars, asm_instruction->return_count,
15447 asm_instruction->has_side_effects);
15448 result->value.type = return_type;
15449 return result;
1576415450}
1576515451
15766static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
15452static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira,
1576715453 IrInstructionArrayType *array_type_instruction)
1576815454{
1576915455 Error err;
1577015456
15771 IrInstruction *size_value = array_type_instruction->size->other;
15457 IrInstruction *size_value = array_type_instruction->size->child;
1577215458 uint64_t size;
1577315459 if (!ir_resolve_usize(ira, size_value, &size))
15774 return ira->codegen->builtin_types.entry_invalid;
15460 return ira->codegen->invalid_instruction;
1577515461
15776 IrInstruction *child_type_value = array_type_instruction->child_type->other;
15462 IrInstruction *child_type_value = array_type_instruction->child_type->child;
1577715463 ZigType *child_type = ir_resolve_type(ira, child_type_value);
1577815464 if (type_is_invalid(child_type))
15779 return ira->codegen->builtin_types.entry_invalid;
15465 return ira->codegen->invalid_instruction;
1578015466 switch (child_type->id) {
1578115467 case ZigTypeIdInvalid: // handled above
1578215468 zig_unreachable();
......@@ -15787,7 +15473,7 @@ static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
1578715473 case ZigTypeIdOpaque:
1578815474 ir_add_error_node(ira, array_type_instruction->base.source_node,
1578915475 buf_sprintf("array of type '%s' not allowed", buf_ptr(&child_type->name)));
15790 return ira->codegen->builtin_types.entry_invalid;
15476 return ira->codegen->invalid_instruction;
1579115477 case ZigTypeIdMetaType:
1579215478 case ZigTypeIdVoid:
1579315479 case ZigTypeIdBool:
......@@ -15809,43 +15495,39 @@ static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
1580915495 case ZigTypeIdPromise:
1581015496 {
1581115497 if ((err = ensure_complete_type(ira->codegen, child_type)))
15812 return ira->codegen->builtin_types.entry_invalid;
15498 return ira->codegen->invalid_instruction;
1581315499 ZigType *result_type = get_array_type(ira->codegen, child_type, size);
15814 ConstExprValue *out_val = ir_build_const_from(ira, &array_type_instruction->base);
15815 out_val->data.x_type = result_type;
15816 return ira->codegen->builtin_types.entry_type;
15500 return ir_const_type(ira, &array_type_instruction->base, result_type);
1581715501 }
1581815502 }
1581915503 zig_unreachable();
1582015504}
1582115505
15822static ZigType *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrInstructionPromiseType *instruction) {
15506static IrInstruction *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrInstructionPromiseType *instruction) {
1582315507 ZigType *promise_type;
1582415508
1582515509 if (instruction->payload_type == nullptr) {
1582615510 promise_type = ira->codegen->builtin_types.entry_promise;
1582715511 } else {
15828 ZigType *payload_type = ir_resolve_type(ira, instruction->payload_type->other);
15512 ZigType *payload_type = ir_resolve_type(ira, instruction->payload_type->child);
1582915513 if (type_is_invalid(payload_type))
15830 return ira->codegen->builtin_types.entry_invalid;
15514 return ira->codegen->invalid_instruction;
1583115515
1583215516 promise_type = get_promise_type(ira->codegen, payload_type);
1583315517 }
1583415518
15835 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15836 out_val->data.x_type = promise_type;
15837 return ira->codegen->builtin_types.entry_type;
15519 return ir_const_type(ira, &instruction->base, promise_type);
1583815520}
1583915521
15840static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
15522static IrInstruction *ir_analyze_instruction_size_of(IrAnalyze *ira,
1584115523 IrInstructionSizeOf *size_of_instruction)
1584215524{
1584315525 Error err;
15844 IrInstruction *type_value = size_of_instruction->type_value->other;
15526 IrInstruction *type_value = size_of_instruction->type_value->child;
1584515527 ZigType *type_entry = ir_resolve_type(ira, type_value);
1584615528
1584715529 if ((err = ensure_complete_type(ira->codegen, type_entry)))
15848 return ira->codegen->builtin_types.entry_invalid;
15530 return ira->codegen->invalid_instruction;
1584915531
1585015532 switch (type_entry->id) {
1585115533 case ZigTypeIdInvalid: // handled above
......@@ -15862,7 +15544,7 @@ static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
1586215544 case ZigTypeIdOpaque:
1586315545 ir_add_error_node(ira, size_of_instruction->base.source_node,
1586415546 buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
15865 return ira->codegen->builtin_types.entry_invalid;
15547 return ira->codegen->invalid_instruction;
1586615548 case ZigTypeIdVoid:
1586715549 case ZigTypeIdBool:
1586815550 case ZigTypeIdInt:
......@@ -15879,18 +15561,16 @@ static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
1587915561 case ZigTypeIdPromise:
1588015562 {
1588115563 uint64_t size_in_bytes = type_size(ira->codegen, type_entry);
15882 ConstExprValue *out_val = ir_build_const_from(ira, &size_of_instruction->base);
15883 bigint_init_unsigned(&out_val->data.x_bigint, size_in_bytes);
15884 return ira->codegen->builtin_types.entry_num_lit_int;
15564 return ir_const_unsigned(ira, &size_of_instruction->base, size_in_bytes);
1588515565 }
1588615566 }
1588715567 zig_unreachable();
1588815568}
1588915569
15890static ZigType *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructionTestNonNull *instruction) {
15891 IrInstruction *value = instruction->value->other;
15570static IrInstruction *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructionTestNonNull *instruction) {
15571 IrInstruction *value = instruction->value->child;
1589215572 if (type_is_invalid(value->value.type))
15893 return ira->codegen->builtin_types.entry_invalid;
15573 return ira->codegen->invalid_instruction;
1589415574
1589515575 ZigType *type_entry = value->value.type;
1589615576
......@@ -15898,43 +15578,39 @@ static ZigType *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructi
1589815578 if (instr_is_comptime(value)) {
1589915579 ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);
1590015580 if (!maybe_val)
15901 return ira->codegen->builtin_types.entry_invalid;
15581 return ira->codegen->invalid_instruction;
1590215582
15903 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15904 out_val->data.x_bool = !optional_value_is_null(maybe_val);
15905 return ira->codegen->builtin_types.entry_bool;
15583 return ir_const_bool(ira, &instruction->base, !optional_value_is_null(maybe_val));
1590615584 }
1590715585
15908 ir_build_test_nonnull_from(&ira->new_irb, &instruction->base, value);
15909 return ira->codegen->builtin_types.entry_bool;
15586 IrInstruction *result = ir_build_test_nonnull(&ira->new_irb,
15587 instruction->base.scope, instruction->base.source_node, value);
15588 result->value.type = ira->codegen->builtin_types.entry_bool;
15589 return result;
1591015590 } else if (type_entry->id == ZigTypeIdNull) {
15911 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15912 out_val->data.x_bool = false;
15913 return ira->codegen->builtin_types.entry_bool;
15591 return ir_const_bool(ira, &instruction->base, false);
1591415592 } else {
15915 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15916 out_val->data.x_bool = true;
15917 return ira->codegen->builtin_types.entry_bool;
15593 return ir_const_bool(ira, &instruction->base, true);
1591815594 }
1591915595}
1592015596
15921static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
15597static IrInstruction *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
1592215598 IrInstructionUnwrapOptional *unwrap_maybe_instruction)
1592315599{
15924 IrInstruction *value = unwrap_maybe_instruction->value->other;
15600 IrInstruction *value = unwrap_maybe_instruction->value->child;
1592515601 if (type_is_invalid(value->value.type))
15926 return ira->codegen->builtin_types.entry_invalid;
15602 return ira->codegen->invalid_instruction;
1592715603
1592815604 ZigType *ptr_type = value->value.type;
1592915605 assert(ptr_type->id == ZigTypeIdPointer);
1593015606
1593115607 ZigType *type_entry = ptr_type->data.pointer.child_type;
1593215608 if (type_is_invalid(type_entry)) {
15933 return ira->codegen->builtin_types.entry_invalid;
15609 return ira->codegen->invalid_instruction;
1593415610 } else if (type_entry->id != ZigTypeIdOptional) {
1593515611 ir_add_error_node(ira, unwrap_maybe_instruction->value->source_node,
1593615612 buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
15937 return ira->codegen->builtin_types.entry_invalid;
15613 return ira->codegen->invalid_instruction;
1593815614 }
1593915615 ZigType *child_type = type_entry->data.maybe.child_type;
1594015616 ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
......@@ -15943,17 +15619,18 @@ static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
1594315619 if (instr_is_comptime(value)) {
1594415620 ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
1594515621 if (!val)
15946 return ira->codegen->builtin_types.entry_invalid;
15622 return ira->codegen->invalid_instruction;
1594715623 ConstExprValue *maybe_val = ir_const_ptr_pointee(ira, val, unwrap_maybe_instruction->base.source_node);
1594815624 if (maybe_val == nullptr)
15949 return ira->codegen->builtin_types.entry_invalid;
15625 return ira->codegen->invalid_instruction;
1595015626
1595115627 if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
1595215628 if (optional_value_is_null(maybe_val)) {
1595315629 ir_add_error(ira, &unwrap_maybe_instruction->base, buf_sprintf("unable to unwrap null"));
15954 return ira->codegen->builtin_types.entry_invalid;
15630 return ira->codegen->invalid_instruction;
1595515631 }
15956 ConstExprValue *out_val = ir_build_const_from(ira, &unwrap_maybe_instruction->base);
15632 IrInstruction *result = ir_const(ira, &unwrap_maybe_instruction->base, result_type);
15633 ConstExprValue *out_val = &result->value;
1595715634 out_val->data.x_ptr.special = ConstPtrSpecialRef;
1595815635 out_val->data.x_ptr.mut = val->data.x_ptr.mut;
1595915636 if (type_is_codegen_pointer(child_type)) {
......@@ -15961,83 +15638,87 @@ static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
1596115638 } else {
1596215639 out_val->data.x_ptr.data.ref.pointee = maybe_val->data.x_optional;
1596315640 }
15964 return result_type;
15641 return result;
1596515642 }
1596615643 }
1596715644
15968 ir_build_unwrap_maybe_from(&ira->new_irb, &unwrap_maybe_instruction->base, value,
15969 unwrap_maybe_instruction->safety_check_on);
15970 return result_type;
15645 IrInstruction *result = ir_build_unwrap_maybe(&ira->new_irb,
15646 unwrap_maybe_instruction->base.scope, unwrap_maybe_instruction->base.source_node,
15647 value, unwrap_maybe_instruction->safety_check_on);
15648 result->value.type = result_type;
15649 return result;
1597115650}
1597215651
15973static ZigType *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCtz *ctz_instruction) {
15974 IrInstruction *value = ctz_instruction->value->other;
15652static IrInstruction *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCtz *ctz_instruction) {
15653 IrInstruction *value = ctz_instruction->value->child;
1597515654 if (type_is_invalid(value->value.type)) {
15976 return ira->codegen->builtin_types.entry_invalid;
15655 return ira->codegen->invalid_instruction;
1597715656 } else if (value->value.type->id == ZigTypeIdInt) {
1597815657 ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
1597915658 value->value.type->data.integral.bit_count);
1598015659 if (value->value.special != ConstValSpecialRuntime) {
15981 size_t result = bigint_ctz(&value->value.data.x_bigint,
15660 size_t result_usize = bigint_ctz(&value->value.data.x_bigint,
1598215661 value->value.type->data.integral.bit_count);
15983 ConstExprValue *out_val = ir_build_const_from(ira, &ctz_instruction->base);
15984 bigint_init_unsigned(&out_val->data.x_bigint, result);
15985 return return_type;
15662 IrInstruction *result = ir_const(ira, &ctz_instruction->base, return_type);
15663 bigint_init_unsigned(&result->value.data.x_bigint, result_usize);
15664 return result;
1598615665 }
1598715666
15988 ir_build_ctz_from(&ira->new_irb, &ctz_instruction->base, value);
15989 return return_type;
15667 IrInstruction *result = ir_build_ctz(&ira->new_irb,
15668 ctz_instruction->base.scope, ctz_instruction->base.source_node, value);
15669 result->value.type = return_type;
15670 return result;
1599015671 } else {
1599115672 ir_add_error_node(ira, ctz_instruction->base.source_node,
1599215673 buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
15993 return ira->codegen->builtin_types.entry_invalid;
15674 return ira->codegen->invalid_instruction;
1599415675 }
1599515676}
1599615677
15997static ZigType *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionClz *clz_instruction) {
15998 IrInstruction *value = clz_instruction->value->other;
15678static IrInstruction *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionClz *clz_instruction) {
15679 IrInstruction *value = clz_instruction->value->child;
1599915680 if (type_is_invalid(value->value.type)) {
16000 return ira->codegen->builtin_types.entry_invalid;
15681 return ira->codegen->invalid_instruction;
1600115682 } else if (value->value.type->id == ZigTypeIdInt) {
1600215683 ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
1600315684 value->value.type->data.integral.bit_count);
1600415685 if (value->value.special != ConstValSpecialRuntime) {
16005 size_t result = bigint_clz(&value->value.data.x_bigint,
15686 size_t result_usize = bigint_clz(&value->value.data.x_bigint,
1600615687 value->value.type->data.integral.bit_count);
16007 ConstExprValue *out_val = ir_build_const_from(ira, &clz_instruction->base);
16008 bigint_init_unsigned(&out_val->data.x_bigint, result);
16009 return return_type;
15688 IrInstruction *result = ir_const(ira, &clz_instruction->base, return_type);
15689 bigint_init_unsigned(&result->value.data.x_bigint, result_usize);
15690 return result;
1601015691 }
1601115692
16012 ir_build_clz_from(&ira->new_irb, &clz_instruction->base, value);
16013 return return_type;
15693 IrInstruction *result = ir_build_clz(&ira->new_irb,
15694 clz_instruction->base.scope, clz_instruction->base.source_node, value);
15695 result->value.type = return_type;
15696 return result;
1601415697 } else {
1601515698 ir_add_error_node(ira, clz_instruction->base.source_node,
1601615699 buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
16017 return ira->codegen->builtin_types.entry_invalid;
15700 return ira->codegen->invalid_instruction;
1601815701 }
1601915702}
1602015703
16021static ZigType *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPopCount *instruction) {
16022 IrInstruction *value = instruction->value->other;
15704static IrInstruction *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPopCount *instruction) {
15705 IrInstruction *value = instruction->value->child;
1602315706 if (type_is_invalid(value->value.type))
16024 return ira->codegen->builtin_types.entry_invalid;
15707 return ira->codegen->invalid_instruction;
1602515708
1602615709 if (value->value.type->id != ZigTypeIdInt && value->value.type->id != ZigTypeIdComptimeInt) {
1602715710 ir_add_error(ira, value,
1602815711 buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
16029 return ira->codegen->builtin_types.entry_invalid;
15712 return ira->codegen->invalid_instruction;
1603015713 }
1603115714
1603215715 if (instr_is_comptime(value)) {
1603315716 ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
1603415717 if (!val)
16035 return ira->codegen->builtin_types.entry_invalid;
15718 return ira->codegen->invalid_instruction;
1603615719 if (bigint_cmp_zero(&val->data.x_bigint) != CmpLT) {
1603715720 size_t result = bigint_popcount_unsigned(&val->data.x_bigint);
16038 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16039 bigint_init_unsigned(&out_val->data.x_bigint, result);
16040 return ira->codegen->builtin_types.entry_num_lit_int;
15721 return ir_const_unsigned(ira, &instruction->base, result);
1604115722 }
1604215723 if (value->value.type->id == ZigTypeIdComptimeInt) {
1604315724 Buf *val_buf = buf_alloc();
......@@ -16045,19 +15726,16 @@ static ZigType *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPo
1604515726 ir_add_error(ira, &instruction->base,
1604615727 buf_sprintf("@popCount on negative %s value %s",
1604715728 buf_ptr(&value->value.type->name), buf_ptr(val_buf)));
16048 return ira->codegen->builtin_types.entry_invalid;
15729 return ira->codegen->invalid_instruction;
1604915730 }
1605015731 size_t result = bigint_popcount_signed(&val->data.x_bigint, value->value.type->data.integral.bit_count);
16051 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16052 bigint_init_unsigned(&out_val->data.x_bigint, result);
16053 return ira->codegen->builtin_types.entry_num_lit_int;
15732 return ir_const_unsigned(ira, &instruction->base, result);
1605415733 }
1605515734
1605615735 IrInstruction *result = ir_build_pop_count(&ira->new_irb, instruction->base.scope,
1605715736 instruction->base.source_node, value);
1605815737 result->value.type = get_smallest_unsigned_int_type(ira->codegen, value->value.type->data.integral.bit_count);
16059 ir_link_new_instruction(result, &instruction->base);
16060 return result->value.type;
15738 return result;
1606115739}
1606215740
1606315741static IrInstruction *ir_analyze_union_tag(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *value) {
......@@ -16103,15 +15781,15 @@ static IrInstruction *ir_analyze_union_tag(IrAnalyze *ira, IrInstruction *source
1610315781 return result;
1610415782}
1610515783
16106static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
15784static IrInstruction *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1610715785 IrInstructionSwitchBr *switch_br_instruction)
1610815786{
16109 IrInstruction *target_value = switch_br_instruction->target_value->other;
15787 IrInstruction *target_value = switch_br_instruction->target_value->child;
1611015788 if (type_is_invalid(target_value->value.type))
1611115789 return ir_unreach_error(ira);
1611215790
1611315791 if (switch_br_instruction->switch_prongs_void != nullptr) {
16114 if (type_is_invalid(switch_br_instruction->switch_prongs_void->other->value.type)) {
15792 if (type_is_invalid(switch_br_instruction->switch_prongs_void->child->value.type)) {
1611515793 return ir_unreach_error(ira);
1611615794 }
1611715795 }
......@@ -16120,8 +15798,8 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1612015798 size_t case_count = switch_br_instruction->case_count;
1612115799
1612215800 bool is_comptime;
16123 if (!ir_resolve_comptime(ira, switch_br_instruction->is_comptime->other, &is_comptime))
16124 return ira->codegen->builtin_types.entry_invalid;
15801 if (!ir_resolve_comptime(ira, switch_br_instruction->is_comptime->child, &is_comptime))
15802 return ira->codegen->invalid_instruction;
1612515803
1612615804 if (is_comptime || instr_is_comptime(target_value)) {
1612715805 ConstExprValue *target_val = ir_resolve_const(ira, target_value, UndefBad);
......@@ -16131,7 +15809,7 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1613115809 IrBasicBlock *old_dest_block = switch_br_instruction->else_block;
1613215810 for (size_t i = 0; i < case_count; i += 1) {
1613315811 IrInstructionSwitchBrCase *old_case = &switch_br_instruction->cases[i];
16134 IrInstruction *case_value = old_case->value->other;
15812 IrInstruction *case_value = old_case->value->child;
1613515813 if (type_is_invalid(case_value->value.type))
1613615814 return ir_unreach_error(ira);
1613715815
......@@ -16159,8 +15837,11 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1615915837 return ir_inline_bb(ira, &switch_br_instruction->base, old_dest_block);
1616015838 } else {
1616115839 IrBasicBlock *new_dest_block = ir_get_new_bb(ira, old_dest_block, &switch_br_instruction->base);
16162 ir_build_br_from(&ira->new_irb, &switch_br_instruction->base, new_dest_block);
16163 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
15840 IrInstruction *result = ir_build_br(&ira->new_irb,
15841 switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
15842 new_dest_block, nullptr);
15843 result->value.type = ira->codegen->builtin_types.entry_unreachable;
15844 return ir_finish_anal(ira, result);
1616415845 }
1616515846 }
1616615847
......@@ -16178,7 +15859,7 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1617815859 new_case->block->ref_instruction = nullptr;
1617915860
1618015861 IrInstruction *old_value = old_case->value;
16181 IrInstruction *new_value = old_value->other;
15862 IrInstruction *new_value = old_value->child;
1618215863 if (type_is_invalid(new_value->value.type))
1618315864 continue;
1618415865
......@@ -16206,32 +15887,31 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
1620615887 }
1620715888
1620815889 IrBasicBlock *new_else_block = ir_get_new_bb(ira, switch_br_instruction->else_block, &switch_br_instruction->base);
16209 ir_build_switch_br_from(&ira->new_irb, &switch_br_instruction->base,
16210 target_value, new_else_block, case_count, cases, nullptr, nullptr);
16211 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
15890 IrInstruction *result = ir_build_switch_br(&ira->new_irb,
15891 switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
15892 target_value, new_else_block, case_count, cases, nullptr, nullptr);
15893 result->value.type = ira->codegen->builtin_types.entry_unreachable;
15894 return ir_finish_anal(ira, result);
1621215895}
1621315896
16214static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
15897static IrInstruction *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1621515898 IrInstructionSwitchTarget *switch_target_instruction)
1621615899{
1621715900 Error err;
16218 IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->other;
15901 IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->child;
1621915902 if (type_is_invalid(target_value_ptr->value.type))
16220 return ira->codegen->builtin_types.entry_invalid;
15903 return ira->codegen->invalid_instruction;
1622115904
1622215905 if (target_value_ptr->value.type->id == ZigTypeIdMetaType) {
1622315906 assert(instr_is_comptime(target_value_ptr));
1622415907 ZigType *ptr_type = target_value_ptr->value.data.x_type;
1622515908 assert(ptr_type->id == ZigTypeIdPointer);
16226 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16227 out_val->type = ira->codegen->builtin_types.entry_type;
16228 out_val->data.x_type = ptr_type->data.pointer.child_type;
16229 return out_val->type;
15909 return ir_const_type(ira, &switch_target_instruction->base, ptr_type->data.pointer.child_type);
1623015910 }
1623115911
1623215912 if (target_value_ptr->value.type->id != ZigTypeIdPointer) {
1623315913 ir_add_error(ira, target_value_ptr, buf_sprintf("invalid deref on switch target"));
16234 return ira->codegen->builtin_types.entry_invalid;
15914 return ira->codegen->invalid_instruction;
1623515915 }
1623615916
1623715917 ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
......@@ -16239,13 +15919,13 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1623915919 if (instr_is_comptime(target_value_ptr)) {
1624015920 pointee_val = ir_const_ptr_pointee(ira, &target_value_ptr->value, target_value_ptr->source_node);
1624115921 if (pointee_val == nullptr)
16242 return ira->codegen->builtin_types.entry_invalid;
15922 return ira->codegen->invalid_instruction;
1624315923
1624415924 if (pointee_val->special == ConstValSpecialRuntime)
1624515925 pointee_val = nullptr;
1624615926 }
1624715927 if ((err = ensure_complete_type(ira->codegen, target_type)))
16248 return ira->codegen->builtin_types.entry_invalid;
15928 return ira->codegen->invalid_instruction;
1624915929
1625015930 switch (target_type->id) {
1625115931 case ZigTypeIdInvalid:
......@@ -16261,16 +15941,20 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1626115941 case ZigTypeIdPromise:
1626215942 case ZigTypeIdFn:
1626315943 case ZigTypeIdNamespace:
16264 case ZigTypeIdErrorSet:
15944 case ZigTypeIdErrorSet: {
1626515945 if (pointee_val) {
16266 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16267 copy_const_val(out_val, pointee_val, true);
16268 out_val->type = target_type;
16269 return target_type;
15946 IrInstruction *result = ir_const(ira, &switch_target_instruction->base, nullptr);
15947 copy_const_val(&result->value, pointee_val, true);
15948 result->value.type = target_type;
15949 return result;
1627015950 }
1627115951
16272 ir_build_load_ptr_from(&ira->new_irb, &switch_target_instruction->base, target_value_ptr);
16273 return target_type;
15952 IrInstruction *result = ir_build_load_ptr(&ira->new_irb,
15953 switch_target_instruction->base.scope, switch_target_instruction->base.source_node,
15954 target_value_ptr);
15955 result->value.type = target_type;
15956 return result;
15957 }
1627415958 case ZigTypeIdUnion: {
1627515959 AstNode *decl_node = target_type->data.unionation.decl_node;
1627615960 if (!decl_node->data.container_decl.auto_enum &&
......@@ -16280,21 +15964,21 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1628015964 buf_sprintf("switch on union which has no attached enum"));
1628115965 add_error_note(ira->codegen, msg, decl_node,
1628215966 buf_sprintf("consider 'union(enum)' here"));
16283 return ira->codegen->builtin_types.entry_invalid;
15967 return ira->codegen->invalid_instruction;
1628415968 }
1628515969 ZigType *tag_type = target_type->data.unionation.tag_type;
1628615970 assert(tag_type != nullptr);
1628715971 assert(tag_type->id == ZigTypeIdEnum);
1628815972 if (pointee_val) {
16289 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16290 bigint_init_bigint(&out_val->data.x_enum_tag, &pointee_val->data.x_union.tag);
16291 return tag_type;
15973 IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
15974 bigint_init_bigint(&result->value.data.x_enum_tag, &pointee_val->data.x_union.tag);
15975 return result;
1629215976 }
1629315977 if (tag_type->data.enumeration.src_field_count == 1) {
16294 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
15978 IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
1629515979 TypeEnumField *only_field = &tag_type->data.enumeration.fields[0];
16296 bigint_init_bigint(&out_val->data.x_enum_tag, &only_field->value);
16297 return tag_type;
15980 bigint_init_bigint(&result->value.data.x_enum_tag, &only_field->value);
15981 return result;
1629815982 }
1629915983
1630015984 IrInstruction *union_value = ir_build_load_ptr(&ira->new_irb, switch_target_instruction->base.scope,
......@@ -16304,30 +15988,28 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1630415988 IrInstruction *union_tag_inst = ir_build_union_tag(&ira->new_irb, switch_target_instruction->base.scope,
1630515989 switch_target_instruction->base.source_node, union_value);
1630615990 union_tag_inst->value.type = tag_type;
16307 ir_link_new_instruction(union_tag_inst, &switch_target_instruction->base);
16308 return tag_type;
15991 return union_tag_inst;
1630915992 }
1631015993 case ZigTypeIdEnum: {
1631115994 if ((err = type_resolve(ira->codegen, target_type, ResolveStatusZeroBitsKnown)))
16312 return ira->codegen->builtin_types.entry_invalid;
15995 return ira->codegen->invalid_instruction;
1631315996 if (target_type->data.enumeration.src_field_count < 2) {
1631415997 TypeEnumField *only_field = &target_type->data.enumeration.fields[0];
16315 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16316 bigint_init_bigint(&out_val->data.x_enum_tag, &only_field->value);
16317 return target_type;
15998 IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
15999 bigint_init_bigint(&result->value.data.x_enum_tag, &only_field->value);
16000 return result;
1631816001 }
1631916002
1632016003 if (pointee_val) {
16321 ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
16322 bigint_init_bigint(&out_val->data.x_enum_tag, &pointee_val->data.x_enum_tag);
16323 return target_type;
16004 IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
16005 bigint_init_bigint(&result->value.data.x_enum_tag, &pointee_val->data.x_enum_tag);
16006 return result;
1632416007 }
1632516008
1632616009 IrInstruction *enum_value = ir_build_load_ptr(&ira->new_irb, switch_target_instruction->base.scope,
1632716010 switch_target_instruction->base.source_node, target_value_ptr);
1632816011 enum_value->value.type = target_type;
16329 ir_link_new_instruction(enum_value, &switch_target_instruction->base);
16330 return target_type;
16012 return enum_value;
1633116013 }
1633216014 case ZigTypeIdErrorUnion:
1633316015 case ZigTypeIdUnreachable:
......@@ -16341,26 +16023,26 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
1634116023 case ZigTypeIdOpaque:
1634216024 ir_add_error(ira, &switch_target_instruction->base,
1634316025 buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
16344 return ira->codegen->builtin_types.entry_invalid;
16026 return ira->codegen->invalid_instruction;
1634516027 }
1634616028 zig_unreachable();
1634716029}
1634816030
16349static ZigType *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionSwitchVar *instruction) {
16350 IrInstruction *target_value_ptr = instruction->target_value_ptr->other;
16031static IrInstruction *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionSwitchVar *instruction) {
16032 IrInstruction *target_value_ptr = instruction->target_value_ptr->child;
1635116033 if (type_is_invalid(target_value_ptr->value.type))
16352 return ira->codegen->builtin_types.entry_invalid;
16034 return ira->codegen->invalid_instruction;
1635316035
16354 IrInstruction *prong_value = instruction->prong_value->other;
16036 IrInstruction *prong_value = instruction->prong_value->child;
1635516037 if (type_is_invalid(prong_value->value.type))
16356 return ira->codegen->builtin_types.entry_invalid;
16038 return ira->codegen->invalid_instruction;
1635716039
1635816040 assert(target_value_ptr->value.type->id == ZigTypeIdPointer);
1635916041 ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
1636016042 if (target_type->id == ZigTypeIdUnion) {
1636116043 ConstExprValue *prong_val = ir_resolve_const(ira, prong_value, UndefBad);
1636216044 if (!prong_val)
16363 return ira->codegen->builtin_types.entry_invalid;
16045 return ira->codegen->invalid_instruction;
1636416046
1636516047 assert(prong_value->value.type->id == ZigTypeIdEnum);
1636616048 TypeUnionField *field = find_union_field_by_tag(target_type, &prong_val->data.x_enum_tag);
......@@ -16368,43 +16050,46 @@ static ZigType *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionS
1636816050 if (instr_is_comptime(target_value_ptr)) {
1636916051 ConstExprValue *target_val_ptr = ir_resolve_const(ira, target_value_ptr, UndefBad);
1637016052 if (!target_value_ptr)
16371 return ira->codegen->builtin_types.entry_invalid;
16053 return ira->codegen->invalid_instruction;
1637216054
1637316055 ConstExprValue *pointee_val = ir_const_ptr_pointee(ira, target_val_ptr, instruction->base.source_node);
1637416056 if (pointee_val == nullptr)
16375 return ira->codegen->builtin_types.entry_invalid;
16057 return ira->codegen->invalid_instruction;
1637616058
16377 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16059 IrInstruction *result = ir_const(ira, &instruction->base,
16060 get_pointer_to_type(ira->codegen, field->type_entry,
16061 target_val_ptr->type->data.pointer.is_const));
16062 ConstExprValue *out_val = &result->value;
1637816063 out_val->data.x_ptr.special = ConstPtrSpecialRef;
1637916064 out_val->data.x_ptr.mut = target_val_ptr->data.x_ptr.mut;
1638016065 out_val->data.x_ptr.data.ref.pointee = pointee_val->data.x_union.payload;
16381 return get_pointer_to_type(ira->codegen, field->type_entry, target_val_ptr->type->data.pointer.is_const);
16066 return result;
1638216067 }
1638316068
16384 ir_build_union_field_ptr_from(&ira->new_irb, &instruction->base, target_value_ptr, field);
16385 return get_pointer_to_type(ira->codegen, field->type_entry,
16069 IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb,
16070 instruction->base.scope, instruction->base.source_node, target_value_ptr, field);
16071 result->value.type = get_pointer_to_type(ira->codegen, field->type_entry,
1638616072 target_value_ptr->value.type->data.pointer.is_const);
16073 return result;
1638716074 } else {
1638816075 ir_add_error(ira, &instruction->base,
1638916076 buf_sprintf("switch on type '%s' provides no expression parameter", buf_ptr(&target_type->name)));
16390 return ira->codegen->builtin_types.entry_invalid;
16077 return ira->codegen->invalid_instruction;
1639116078 }
1639216079}
1639316080
16394static ZigType *ir_analyze_instruction_union_tag(IrAnalyze *ira, IrInstructionUnionTag *instruction) {
16395 IrInstruction *value = instruction->value->other;
16396 IrInstruction *new_instruction = ir_analyze_union_tag(ira, &instruction->base, value);
16397 ir_link_new_instruction(new_instruction, &instruction->base);
16398 return new_instruction->value.type;
16081static IrInstruction *ir_analyze_instruction_union_tag(IrAnalyze *ira, IrInstructionUnionTag *instruction) {
16082 IrInstruction *value = instruction->value->child;
16083 return ir_analyze_union_tag(ira, &instruction->base, value);
1639916084}
1640016085
16401static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImport *import_instruction) {
16086static IrInstruction *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImport *import_instruction) {
1640216087 Error err;
1640316088
16404 IrInstruction *name_value = import_instruction->name->other;
16089 IrInstruction *name_value = import_instruction->name->child;
1640516090 Buf *import_target_str = ir_resolve_str(ira, name_value);
1640616091 if (!import_target_str)
16407 return ira->codegen->builtin_types.entry_invalid;
16092 return ira->codegen->invalid_instruction;
1640816093
1640916094 AstNode *source_node = import_instruction->base.source_node;
1641016095 ImportTableEntry *import = source_node->owner;
......@@ -16439,20 +16124,21 @@ static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImpor
1643916124
1644016125 auto import_entry = ira->codegen->import_table.maybe_get(resolved_path);
1644116126 if (import_entry) {
16442 ConstExprValue *out_val = ir_build_const_from(ira, &import_instruction->base);
16443 out_val->data.x_import = import_entry->value;
16444 return ira->codegen->builtin_types.entry_namespace;
16127 IrInstruction *result = ir_const(ira, &import_instruction->base,
16128 ira->codegen->builtin_types.entry_namespace);
16129 result->value.data.x_import = import_entry->value;
16130 return result;
1644516131 }
1644616132
1644716133 if ((err = file_fetch(ira->codegen, resolved_path, import_code))) {
1644816134 if (err == ErrorFileNotFound) {
1644916135 ir_add_error_node(ira, source_node,
1645016136 buf_sprintf("unable to find '%s'", buf_ptr(import_target_path)));
16451 return ira->codegen->builtin_types.entry_invalid;
16137 return ira->codegen->invalid_instruction;
1645216138 } else {
1645316139 ir_add_error_node(ira, source_node,
1645416140 buf_sprintf("unable to open '%s': %s", buf_ptr(&full_path), err_str(err)));
16455 return ira->codegen->builtin_types.entry_invalid;
16141 return ira->codegen->invalid_instruction;
1645616142 }
1645716143 }
1645816144
......@@ -16460,27 +16146,26 @@ static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImpor
1646016146
1646116147 scan_import(ira->codegen, target_import);
1646216148
16463 ConstExprValue *out_val = ir_build_const_from(ira, &import_instruction->base);
16464 out_val->data.x_import = target_import;
16465 return ira->codegen->builtin_types.entry_namespace;
16466
16149 IrInstruction *result = ir_const(ira, &import_instruction->base, ira->codegen->builtin_types.entry_namespace);
16150 result->value.data.x_import = target_import;
16151 return result;
1646716152}
1646816153
16469static ZigType *ir_analyze_instruction_array_len(IrAnalyze *ira,
16154static IrInstruction *ir_analyze_instruction_array_len(IrAnalyze *ira,
1647016155 IrInstructionArrayLen *array_len_instruction)
1647116156{
16472 IrInstruction *array_value = array_len_instruction->array_value->other;
16157 IrInstruction *array_value = array_len_instruction->array_value->child;
1647316158 ZigType *type_entry = array_value->value.type;
1647416159 if (type_is_invalid(type_entry)) {
16475 return ira->codegen->builtin_types.entry_invalid;
16160 return ira->codegen->invalid_instruction;
1647616161 } else if (type_entry->id == ZigTypeIdArray) {
16477 return ir_analyze_const_usize(ira, &array_len_instruction->base,
16162 return ir_const_usize(ira, &array_len_instruction->base,
1647816163 type_entry->data.array.len);
1647916164 } else if (is_slice(type_entry)) {
1648016165 if (array_value->value.special != ConstValSpecialRuntime) {
1648116166 ConstExprValue *len_val = &array_value->value.data.x_struct.fields[slice_len_index];
1648216167 if (len_val->special != ConstValSpecialRuntime) {
16483 return ir_analyze_const_usize(ira, &array_len_instruction->base,
16168 return ir_const_usize(ira, &array_len_instruction->base,
1648416169 bigint_as_unsigned(&len_val->data.x_bigint));
1648516170 }
1648616171 }
......@@ -16488,57 +16173,61 @@ static ZigType *ir_analyze_instruction_array_len(IrAnalyze *ira,
1648816173 IrInstruction *len_ptr = ir_build_struct_field_ptr(&ira->new_irb, array_len_instruction->base.scope,
1648916174 array_len_instruction->base.source_node, array_value, field);
1649016175 len_ptr->value.type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_usize, true);
16491 ir_build_load_ptr_from(&ira->new_irb, &array_len_instruction->base, len_ptr);
16492 return ira->codegen->builtin_types.entry_usize;
16176 IrInstruction *result = ir_build_load_ptr(&ira->new_irb,
16177 array_len_instruction->base.scope, array_len_instruction->base.source_node, len_ptr);
16178 result->value.type = ira->codegen->builtin_types.entry_usize;
16179 return result;
1649316180 } else {
1649416181 ir_add_error_node(ira, array_len_instruction->base.source_node,
1649516182 buf_sprintf("type '%s' has no field 'len'", buf_ptr(&array_value->value.type->name)));
16496 return ira->codegen->builtin_types.entry_invalid;
16183 return ira->codegen->invalid_instruction;
1649716184 }
1649816185}
1649916186
16500static ZigType *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionRef *ref_instruction) {
16501 IrInstruction *value = ref_instruction->value->other;
16502 return ir_analyze_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
16187static IrInstruction *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionRef *ref_instruction) {
16188 IrInstruction *value = ref_instruction->value->child;
16189 if (type_is_invalid(value->value.type))
16190 return ira->codegen->invalid_instruction;
16191 return ir_get_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
1650316192}
1650416193
16505static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
16194static IrInstruction *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
1650616195 ZigType *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
1650716196{
1650816197 Error err;
1650916198 assert(container_type->id == ZigTypeIdUnion);
1651016199
1651116200 if ((err = ensure_complete_type(ira->codegen, container_type)))
16512 return ira->codegen->builtin_types.entry_invalid;
16201 return ira->codegen->invalid_instruction;
1651316202
1651416203 if (instr_field_count != 1) {
1651516204 ir_add_error(ira, instruction,
1651616205 buf_sprintf("union initialization expects exactly one field"));
16517 return ira->codegen->builtin_types.entry_invalid;
16206 return ira->codegen->invalid_instruction;
1651816207 }
1651916208
1652016209 IrInstructionContainerInitFieldsField *field = &fields[0];
16521 IrInstruction *field_value = field->value->other;
16210 IrInstruction *field_value = field->value->child;
1652216211 if (type_is_invalid(field_value->value.type))
16523 return ira->codegen->builtin_types.entry_invalid;
16212 return ira->codegen->invalid_instruction;
1652416213
1652516214 TypeUnionField *type_field = find_union_type_field(container_type, field->name);
1652616215 if (!type_field) {
1652716216 ir_add_error_node(ira, field->source_node,
1652816217 buf_sprintf("no member named '%s' in union '%s'",
1652916218 buf_ptr(field->name), buf_ptr(&container_type->name)));
16530 return ira->codegen->builtin_types.entry_invalid;
16219 return ira->codegen->invalid_instruction;
1653116220 }
1653216221
1653316222 if (type_is_invalid(type_field->type_entry))
16534 return ira->codegen->builtin_types.entry_invalid;
16223 return ira->codegen->invalid_instruction;
1653516224
1653616225 IrInstruction *casted_field_value = ir_implicit_cast(ira, field_value, type_field->type_entry);
1653716226 if (casted_field_value == ira->codegen->invalid_instruction)
16538 return ira->codegen->builtin_types.entry_invalid;
16227 return ira->codegen->invalid_instruction;
1653916228
1654016229 if ((err = type_resolve(ira->codegen, casted_field_value->value.type, ResolveStatusZeroBitsKnown)))
16541 return ira->codegen->builtin_types.entry_invalid;
16230 return ira->codegen->invalid_instruction;
1654216231
1654316232 bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope);
1654416233 if (is_comptime || casted_field_value->value.special != ConstValSpecialRuntime ||
......@@ -16546,9 +16235,10 @@ static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruc
1654616235 {
1654716236 ConstExprValue *field_val = ir_resolve_const(ira, casted_field_value, UndefOk);
1654816237 if (!field_val)
16549 return ira->codegen->builtin_types.entry_invalid;
16238 return ira->codegen->invalid_instruction;
1655016239
16551 ConstExprValue *out_val = ir_build_const_from(ira, instruction);
16240 IrInstruction *result = ir_const(ira, instruction, container_type);
16241 ConstExprValue *out_val = &result->value;
1655216242 out_val->data.x_union.payload = field_val;
1655316243 out_val->data.x_union.tag = type_field->enum_field->value;
1655416244
......@@ -16558,17 +16248,18 @@ static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruc
1655816248 parent->data.p_union.union_val = out_val;
1655916249 }
1656016250
16561 return container_type;
16251 return result;
1656216252 }
1656316253
16564 IrInstruction *new_instruction = ir_build_union_init_from(&ira->new_irb, instruction,
16254 IrInstruction *new_instruction = ir_build_union_init(&ira->new_irb,
16255 instruction->scope, instruction->source_node,
1656516256 container_type, type_field, casted_field_value);
16566
16257 new_instruction->value.type = container_type;
1656716258 ir_add_alloca(ira, new_instruction, container_type);
16568 return container_type;
16259 return new_instruction;
1656916260}
1657016261
16571static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
16262static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
1657216263 ZigType *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
1657316264{
1657416265 Error err;
......@@ -16579,11 +16270,11 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
1657916270 ir_add_error(ira, instruction,
1658016271 buf_sprintf("type '%s' does not support struct initialization syntax",
1658116272 buf_ptr(&container_type->name)));
16582 return ira->codegen->builtin_types.entry_invalid;
16273 return ira->codegen->invalid_instruction;
1658316274 }
1658416275
1658516276 if ((err = ensure_complete_type(ira->codegen, container_type)))
16586 return ira->codegen->builtin_types.entry_invalid;
16277 return ira->codegen->invalid_instruction;
1658716278
1658816279 size_t actual_field_count = container_type->data.structure.src_field_count;
1658916280
......@@ -16602,31 +16293,31 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
1660216293 for (size_t i = 0; i < instr_field_count; i += 1) {
1660316294 IrInstructionContainerInitFieldsField *field = &fields[i];
1660416295
16605 IrInstruction *field_value = field->value->other;
16296 IrInstruction *field_value = field->value->child;
1660616297 if (type_is_invalid(field_value->value.type))
16607 return ira->codegen->builtin_types.entry_invalid;
16298 return ira->codegen->invalid_instruction;
1660816299
1660916300 TypeStructField *type_field = find_struct_type_field(container_type, field->name);
1661016301 if (!type_field) {
1661116302 ir_add_error_node(ira, field->source_node,
1661216303 buf_sprintf("no member named '%s' in struct '%s'",
1661316304 buf_ptr(field->name), buf_ptr(&container_type->name)));
16614 return ira->codegen->builtin_types.entry_invalid;
16305 return ira->codegen->invalid_instruction;
1661516306 }
1661616307
1661716308 if (type_is_invalid(type_field->type_entry))
16618 return ira->codegen->builtin_types.entry_invalid;
16309 return ira->codegen->invalid_instruction;
1661916310
1662016311 IrInstruction *casted_field_value = ir_implicit_cast(ira, field_value, type_field->type_entry);
1662116312 if (casted_field_value == ira->codegen->invalid_instruction)
16622 return ira->codegen->builtin_types.entry_invalid;
16313 return ira->codegen->invalid_instruction;
1662316314
1662416315 size_t field_index = type_field->src_index;
1662516316 AstNode *existing_assign_node = field_assign_nodes[field_index];
1662616317 if (existing_assign_node) {
1662716318 ErrorMsg *msg = ir_add_error_node(ira, field->source_node, buf_sprintf("duplicate field"));
1662816319 add_error_note(ira->codegen, msg, existing_assign_node, buf_sprintf("other field here"));
16629 return ira->codegen->builtin_types.entry_invalid;
16320 return ira->codegen->invalid_instruction;
1663016321 }
1663116322 field_assign_nodes[field_index] = field->source_node;
1663216323
......@@ -16637,7 +16328,7 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
1663716328 if (is_comptime || casted_field_value->value.special != ConstValSpecialRuntime) {
1663816329 ConstExprValue *field_val = ir_resolve_const(ira, casted_field_value, UndefOk);
1663916330 if (!field_val)
16640 return ira->codegen->builtin_types.entry_invalid;
16331 return ira->codegen->invalid_instruction;
1664116332
1664216333 copy_const_val(&const_val.data.x_struct.fields[field_index], field_val, true);
1664316334 } else {
......@@ -16656,11 +16347,14 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
1665616347 }
1665716348 }
1665816349 if (any_missing)
16659 return ira->codegen->builtin_types.entry_invalid;
16350 return ira->codegen->invalid_instruction;
1666016351
1666116352 if (const_val.special == ConstValSpecialStatic) {
16662 ConstExprValue *out_val = ir_build_const_from(ira, instruction);
16353 IrInstruction *result = ir_const(ira, instruction, nullptr);
16354 ConstExprValue *out_val = &result->value;
16355 // TODO copy_const_val?
1666316356 *out_val = const_val;
16357 result->value.type = container_type;
1666416358
1666516359 for (size_t i = 0; i < instr_field_count; i += 1) {
1666616360 ConstExprValue *field_val = &out_val->data.x_struct.fields[i];
......@@ -16672,34 +16366,35 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
1667216366 }
1667316367 }
1667416368
16675 return container_type;
16369 return result;
1667616370 }
1667716371
1667816372 if (is_comptime) {
1667916373 ir_add_error_node(ira, first_non_const_instruction->source_node,
1668016374 buf_sprintf("unable to evaluate constant expression"));
16681 return ira->codegen->builtin_types.entry_invalid;
16375 return ira->codegen->invalid_instruction;
1668216376 }
1668316377
16684 IrInstruction *new_instruction = ir_build_struct_init_from(&ira->new_irb, instruction,
16378 IrInstruction *new_instruction = ir_build_struct_init(&ira->new_irb,
16379 instruction->scope, instruction->source_node,
1668516380 container_type, actual_field_count, new_fields);
16686
16381 new_instruction->value.type = container_type;
1668716382 ir_add_alloca(ira, new_instruction, container_type);
16688 return container_type;
16383 return new_instruction;
1668916384}
1669016385
16691static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
16386static IrInstruction *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1669216387 IrInstructionContainerInitList *instruction)
1669316388{
16694 IrInstruction *container_type_value = instruction->container_type->other;
16389 IrInstruction *container_type_value = instruction->container_type->child;
1669516390 if (type_is_invalid(container_type_value->value.type))
16696 return ira->codegen->builtin_types.entry_invalid;
16391 return ira->codegen->invalid_instruction;
1669716392
1669816393 size_t elem_count = instruction->item_count;
1669916394 if (container_type_value->value.type->id == ZigTypeIdMetaType) {
1670016395 ZigType *container_type = ir_resolve_type(ira, container_type_value);
1670116396 if (type_is_invalid(container_type))
16702 return ira->codegen->builtin_types.entry_invalid;
16397 return ira->codegen->invalid_instruction;
1670316398
1670416399 if (container_type->id == ZigTypeIdStruct && !is_slice(container_type) && elem_count == 0) {
1670516400 return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
......@@ -16715,7 +16410,7 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1671516410 ir_add_error(ira, &instruction->base,
1671616411 buf_sprintf("expected %s literal, found %s literal",
1671716412 buf_ptr(&container_type->name), buf_ptr(&literal_type->name)));
16718 return ira->codegen->builtin_types.entry_invalid;
16413 return ira->codegen->invalid_instruction;
1671916414 }
1672016415 } else {
1672116416 ZigType *pointer_type = container_type->data.structure.fields[slice_ptr_index].type_entry;
......@@ -16737,13 +16432,13 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1673716432 IrInstruction *first_non_const_instruction = nullptr;
1673816433
1673916434 for (size_t i = 0; i < elem_count; i += 1) {
16740 IrInstruction *arg_value = instruction->items[i]->other;
16435 IrInstruction *arg_value = instruction->items[i]->child;
1674116436 if (type_is_invalid(arg_value->value.type))
16742 return ira->codegen->builtin_types.entry_invalid;
16437 return ira->codegen->invalid_instruction;
1674316438
1674416439 IrInstruction *casted_arg = ir_implicit_cast(ira, arg_value, child_type);
1674516440 if (casted_arg == ira->codegen->invalid_instruction)
16746 return ira->codegen->builtin_types.entry_invalid;
16441 return ira->codegen->invalid_instruction;
1674716442
1674816443 new_items[i] = casted_arg;
1674916444
......@@ -16751,7 +16446,7 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1675116446 if (is_comptime || casted_arg->value.special != ConstValSpecialRuntime) {
1675216447 ConstExprValue *elem_val = ir_resolve_const(ira, casted_arg, UndefBad);
1675316448 if (!elem_val)
16754 return ira->codegen->builtin_types.entry_invalid;
16449 return ira->codegen->invalid_instruction;
1675516450
1675616451 copy_const_val(&const_val.data.x_array.data.s_none.elements[i], elem_val, true);
1675716452 } else {
......@@ -16762,8 +16457,11 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1676216457 }
1676316458
1676416459 if (const_val.special == ConstValSpecialStatic) {
16765 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16460 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
16461 ConstExprValue *out_val = &result->value;
16462 // TODO copy_const_val?
1676616463 *out_val = const_val;
16464 result->value.type = fixed_size_array_type;
1676716465 for (size_t i = 0; i < elem_count; i += 1) {
1676816466 ConstExprValue *elem_val = &out_val->data.x_array.data.s_none.elements[i];
1676916467 ConstParent *parent = get_const_val_parent(ira->codegen, elem_val);
......@@ -16773,70 +16471,73 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
1677316471 parent->data.p_array.elem_index = i;
1677416472 }
1677516473 }
16776 return fixed_size_array_type;
16474 return result;
1677716475 }
1677816476
1677916477 if (is_comptime) {
1678016478 ir_add_error_node(ira, first_non_const_instruction->source_node,
1678116479 buf_sprintf("unable to evaluate constant expression"));
16782 return ira->codegen->builtin_types.entry_invalid;
16480 return ira->codegen->invalid_instruction;
1678316481 }
1678416482
16785 IrInstruction *new_instruction = ir_build_container_init_list_from(&ira->new_irb, &instruction->base,
16483 IrInstruction *new_instruction = ir_build_container_init_list(&ira->new_irb,
16484 instruction->base.scope, instruction->base.source_node,
1678616485 container_type_value, elem_count, new_items);
16486 new_instruction->value.type = fixed_size_array_type;
1678716487 ir_add_alloca(ira, new_instruction, fixed_size_array_type);
16788 return fixed_size_array_type;
16488 return new_instruction;
1678916489 } else if (container_type->id == ZigTypeIdVoid) {
1679016490 if (elem_count != 0) {
1679116491 ir_add_error_node(ira, instruction->base.source_node,
1679216492 buf_sprintf("void expression expects no arguments"));
16793 return ira->codegen->builtin_types.entry_invalid;
16493 return ira->codegen->invalid_instruction;
1679416494 }
16795 return ir_analyze_void(ira, &instruction->base);
16495 return ir_const_void(ira, &instruction->base);
1679616496 } else {
1679716497 ir_add_error_node(ira, instruction->base.source_node,
1679816498 buf_sprintf("type '%s' does not support array initialization",
1679916499 buf_ptr(&container_type->name)));
16800 return ira->codegen->builtin_types.entry_invalid;
16500 return ira->codegen->invalid_instruction;
1680116501 }
1680216502 } else {
1680316503 ir_add_error(ira, container_type_value,
1680416504 buf_sprintf("expected type, found '%s' value", buf_ptr(&container_type_value->value.type->name)));
16805 return ira->codegen->builtin_types.entry_invalid;
16505 return ira->codegen->invalid_instruction;
1680616506 }
1680716507}
1680816508
16809static ZigType *ir_analyze_instruction_container_init_fields(IrAnalyze *ira, IrInstructionContainerInitFields *instruction) {
16810 IrInstruction *container_type_value = instruction->container_type->other;
16509static IrInstruction *ir_analyze_instruction_container_init_fields(IrAnalyze *ira, IrInstructionContainerInitFields *instruction) {
16510 IrInstruction *container_type_value = instruction->container_type->child;
1681116511 ZigType *container_type = ir_resolve_type(ira, container_type_value);
1681216512 if (type_is_invalid(container_type))
16813 return ira->codegen->builtin_types.entry_invalid;
16513 return ira->codegen->invalid_instruction;
1681416514
1681516515 return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
1681616516 instruction->field_count, instruction->fields);
1681716517}
1681816518
16819static ZigType *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_instruction,
16519static IrInstruction *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_instruction,
1682016520 IrInstruction *target_type_value, bool is_max)
1682116521{
1682216522 ZigType *target_type = ir_resolve_type(ira, target_type_value);
1682316523 if (type_is_invalid(target_type))
16824 return ira->codegen->builtin_types.entry_invalid;
16524 return ira->codegen->invalid_instruction;
1682516525 switch (target_type->id) {
1682616526 case ZigTypeIdInvalid:
1682716527 zig_unreachable();
1682816528 case ZigTypeIdInt:
1682916529 {
16830 ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
16831 eval_min_max_value(ira->codegen, target_type, out_val, is_max);
16832 return ira->codegen->builtin_types.entry_num_lit_int;
16530 IrInstruction *result = ir_const(ira, source_instruction,
16531 ira->codegen->builtin_types.entry_num_lit_int);
16532 eval_min_max_value(ira->codegen, target_type, &result->value, is_max);
16533 return result;
1683316534 }
1683416535 case ZigTypeIdBool:
1683516536 case ZigTypeIdVoid:
1683616537 {
16837 ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
16838 eval_min_max_value(ira->codegen, target_type, out_val, is_max);
16839 return target_type;
16538 IrInstruction *result = ir_const(ira, source_instruction, target_type);
16539 eval_min_max_value(ira->codegen, target_type, &result->value, is_max);
16540 return result;
1684016541 }
1684116542 case ZigTypeIdEnum:
1684216543 case ZigTypeIdFloat:
......@@ -16865,31 +16566,31 @@ static ZigType *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_instruc
1686516566 "no min value available for type '%s'";
1686616567 ir_add_error(ira, source_instruction,
1686716568 buf_sprintf(err_format, buf_ptr(&target_type->name)));
16868 return ira->codegen->builtin_types.entry_invalid;
16569 return ira->codegen->invalid_instruction;
1686916570 }
1687016571 }
1687116572 zig_unreachable();
1687216573}
1687316574
16874static ZigType *ir_analyze_instruction_min_value(IrAnalyze *ira,
16575static IrInstruction *ir_analyze_instruction_min_value(IrAnalyze *ira,
1687516576 IrInstructionMinValue *instruction)
1687616577{
16877 return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, false);
16578 return ir_analyze_min_max(ira, &instruction->base, instruction->value->child, false);
1687816579}
1687916580
16880static ZigType *ir_analyze_instruction_max_value(IrAnalyze *ira,
16581static IrInstruction *ir_analyze_instruction_max_value(IrAnalyze *ira,
1688116582 IrInstructionMaxValue *instruction)
1688216583{
16883 return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, true);
16584 return ir_analyze_min_max(ira, &instruction->base, instruction->value->child, true);
1688416585}
1688516586
16886static ZigType *ir_analyze_instruction_compile_err(IrAnalyze *ira,
16587static IrInstruction *ir_analyze_instruction_compile_err(IrAnalyze *ira,
1688716588 IrInstructionCompileErr *instruction)
1688816589{
16889 IrInstruction *msg_value = instruction->msg->other;
16590 IrInstruction *msg_value = instruction->msg->child;
1689016591 Buf *msg_buf = ir_resolve_str(ira, msg_value);
1689116592 if (!msg_buf)
16892 return ira->codegen->builtin_types.entry_invalid;
16593 return ira->codegen->invalid_instruction;
1689316594
1689416595 ErrorMsg *msg = ir_add_error(ira, &instruction->base, msg_buf);
1689516596 size_t i = ira->codegen->tld_ref_source_node_stack.length;
......@@ -16904,16 +16605,16 @@ static ZigType *ir_analyze_instruction_compile_err(IrAnalyze *ira,
1690416605 }
1690516606 }
1690616607
16907 return ira->codegen->builtin_types.entry_invalid;
16608 return ira->codegen->invalid_instruction;
1690816609}
1690916610
16910static ZigType *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstructionCompileLog *instruction) {
16611static IrInstruction *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstructionCompileLog *instruction) {
1691116612 Buf buf = BUF_INIT;
1691216613 fprintf(stderr, "| ");
1691316614 for (size_t i = 0; i < instruction->msg_count; i += 1) {
16914 IrInstruction *msg = instruction->msg_list[i]->other;
16615 IrInstruction *msg = instruction->msg_list[i]->child;
1691516616 if (type_is_invalid(msg->value.type))
16916 return ira->codegen->builtin_types.entry_invalid;
16617 return ira->codegen->invalid_instruction;
1691716618 buf_resize(&buf, 0);
1691816619 render_const_value(ira->codegen, &buf, &msg->value);
1691916620 const char *comma_str = (i != 0) ? ", " : "";
......@@ -16925,18 +16626,17 @@ static ZigType *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstruction
1692516626 // invalidate_exec to be called.
1692616627 add_node_error(ira->codegen, instruction->base.source_node, buf_sprintf("found compile log statement"));
1692716628
16928 ir_build_const_from(ira, &instruction->base);
16929 return ira->codegen->builtin_types.entry_void;
16629 return ir_const_void(ira, &instruction->base);
1693016630}
1693116631
16932static ZigType *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErrName *instruction) {
16933 IrInstruction *value = instruction->value->other;
16632static IrInstruction *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErrName *instruction) {
16633 IrInstruction *value = instruction->value->child;
1693416634 if (type_is_invalid(value->value.type))
16935 return ira->codegen->builtin_types.entry_invalid;
16635 return ira->codegen->invalid_instruction;
1693616636
1693716637 IrInstruction *casted_value = ir_implicit_cast(ira, value, value->value.type);
1693816638 if (type_is_invalid(casted_value->value.type))
16939 return ira->codegen->builtin_types.entry_invalid;
16639 return ira->codegen->invalid_instruction;
1694016640
1694116641 ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
1694216642 true, false, PtrLenUnknown, 0, 0, 0);
......@@ -16947,84 +16647,87 @@ static ZigType *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErr
1694716647 ConstExprValue *array_val = create_const_str_lit(ira->codegen, &err->name);
1694816648 err->cached_error_name_val = create_const_slice(ira->codegen, array_val, 0, buf_len(&err->name), true);
1694916649 }
16950 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16951 copy_const_val(out_val, err->cached_error_name_val, true);
16952 return str_type;
16650 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
16651 copy_const_val(&result->value, err->cached_error_name_val, true);
16652 result->value.type = str_type;
16653 return result;
1695316654 }
1695416655
1695516656 ira->codegen->generate_error_name_table = true;
16956 ir_build_err_name_from(&ira->new_irb, &instruction->base, value);
16957 return str_type;
16657
16658 IrInstruction *result = ir_build_err_name(&ira->new_irb,
16659 instruction->base.scope, instruction->base.source_node, value);
16660 result->value.type = str_type;
16661 return result;
1695816662}
1695916663
16960static ZigType *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
16664static IrInstruction *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
1696116665 Error err;
16962 IrInstruction *target = instruction->target->other;
16666 IrInstruction *target = instruction->target->child;
1696316667 if (type_is_invalid(target->value.type))
16964 return ira->codegen->builtin_types.entry_invalid;
16668 return ira->codegen->invalid_instruction;
1696516669
1696616670 assert(target->value.type->id == ZigTypeIdEnum);
1696716671
1696816672 if (instr_is_comptime(target)) {
1696916673 if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusZeroBitsKnown)))
16970 return ira->codegen->builtin_types.entry_invalid;
16674 return ira->codegen->invalid_instruction;
1697116675 TypeEnumField *field = find_enum_field_by_tag(target->value.type, &target->value.data.x_bigint);
1697216676 ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name);
16973 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16974 init_const_slice(ira->codegen, out_val, array_val, 0, buf_len(field->name), true);
16975 return out_val->type;
16677 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
16678 init_const_slice(ira->codegen, &result->value, array_val, 0, buf_len(field->name), true);
16679 return result;
1697616680 }
1697716681
1697816682 IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,
1697916683 instruction->base.source_node, target);
16980 ir_link_new_instruction(result, &instruction->base);
1698116684 ZigType *u8_ptr_type = get_pointer_to_type_extra(
1698216685 ira->codegen, ira->codegen->builtin_types.entry_u8,
1698316686 true, false, PtrLenUnknown,
1698416687 0, 0, 0);
1698516688 result->value.type = get_slice_type(ira->codegen, u8_ptr_type);
16986 return result->value.type;
16689 return result;
1698716690}
1698816691
16989static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
16692static IrInstruction *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
1699016693 IrInstructionFieldParentPtr *instruction)
1699116694{
1699216695 Error err;
16993 IrInstruction *type_value = instruction->type_value->other;
16696 IrInstruction *type_value = instruction->type_value->child;
1699416697 ZigType *container_type = ir_resolve_type(ira, type_value);
1699516698 if (type_is_invalid(container_type))
16996 return ira->codegen->builtin_types.entry_invalid;
16699 return ira->codegen->invalid_instruction;
1699716700
16998 IrInstruction *field_name_value = instruction->field_name->other;
16701 IrInstruction *field_name_value = instruction->field_name->child;
1699916702 Buf *field_name = ir_resolve_str(ira, field_name_value);
1700016703 if (!field_name)
17001 return ira->codegen->builtin_types.entry_invalid;
16704 return ira->codegen->invalid_instruction;
1700216705
17003 IrInstruction *field_ptr = instruction->field_ptr->other;
16706 IrInstruction *field_ptr = instruction->field_ptr->child;
1700416707 if (type_is_invalid(field_ptr->value.type))
17005 return ira->codegen->builtin_types.entry_invalid;
16708 return ira->codegen->invalid_instruction;
1700616709
1700716710 if (container_type->id != ZigTypeIdStruct) {
1700816711 ir_add_error(ira, type_value,
1700916712 buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
17010 return ira->codegen->builtin_types.entry_invalid;
16713 return ira->codegen->invalid_instruction;
1701116714 }
1701216715
1701316716 if ((err = ensure_complete_type(ira->codegen, container_type)))
17014 return ira->codegen->builtin_types.entry_invalid;
16717 return ira->codegen->invalid_instruction;
1701516718
1701616719 TypeStructField *field = find_struct_type_field(container_type, field_name);
1701716720 if (field == nullptr) {
1701816721 ir_add_error(ira, field_name_value,
1701916722 buf_sprintf("struct '%s' has no field '%s'",
1702016723 buf_ptr(&container_type->name), buf_ptr(field_name)));
17021 return ira->codegen->builtin_types.entry_invalid;
16724 return ira->codegen->invalid_instruction;
1702216725 }
1702316726
1702416727 if (field_ptr->value.type->id != ZigTypeIdPointer) {
1702516728 ir_add_error(ira, field_ptr,
1702616729 buf_sprintf("expected pointer, found '%s'", buf_ptr(&field_ptr->value.type->name)));
17027 return ira->codegen->builtin_types.entry_invalid;
16730 return ira->codegen->invalid_instruction;
1702816731 }
1702916732
1703016733 bool is_packed = (container_type->data.structure.layout == ContainerLayoutPacked);
......@@ -17038,7 +16741,7 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
1703816741 field_ptr_align, 0, 0);
1703916742 IrInstruction *casted_field_ptr = ir_implicit_cast(ira, field_ptr, field_ptr_type);
1704016743 if (type_is_invalid(casted_field_ptr->value.type))
17041 return ira->codegen->builtin_types.entry_invalid;
16744 return ira->codegen->invalid_instruction;
1704216745
1704316746 ZigType *result_type = get_pointer_to_type_extra(ira->codegen, container_type,
1704416747 casted_field_ptr->value.type->data.pointer.is_const,
......@@ -17049,11 +16752,11 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
1704916752 if (instr_is_comptime(casted_field_ptr)) {
1705016753 ConstExprValue *field_ptr_val = ir_resolve_const(ira, casted_field_ptr, UndefBad);
1705116754 if (!field_ptr_val)
17052 return ira->codegen->builtin_types.entry_invalid;
16755 return ira->codegen->invalid_instruction;
1705316756
1705416757 if (field_ptr_val->data.x_ptr.special != ConstPtrSpecialBaseStruct) {
1705516758 ir_add_error(ira, field_ptr, buf_sprintf("pointer value not based on parent struct"));
17056 return ira->codegen->builtin_types.entry_invalid;
16759 return ira->codegen->invalid_instruction;
1705716760 }
1705816761
1705916762 size_t ptr_field_index = field_ptr_val->data.x_ptr.data.base_struct.field_index;
......@@ -17062,21 +16765,21 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
1706216765 buf_sprintf("field '%s' has index %" ZIG_PRI_usize " but pointer value is index %" ZIG_PRI_usize " of struct '%s'",
1706316766 buf_ptr(field->name), field->src_index,
1706416767 ptr_field_index, buf_ptr(&container_type->name)));
17065 return ira->codegen->builtin_types.entry_invalid;
16768 return ira->codegen->invalid_instruction;
1706616769 }
1706716770
17068 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
16771 IrInstruction *result = ir_const(ira, &instruction->base, result_type);
16772 ConstExprValue *out_val = &result->value;
1706916773 out_val->data.x_ptr.special = ConstPtrSpecialRef;
1707016774 out_val->data.x_ptr.data.ref.pointee = field_ptr_val->data.x_ptr.data.base_struct.struct_val;
1707116775 out_val->data.x_ptr.mut = field_ptr_val->data.x_ptr.mut;
17072
17073 return result_type;
16776 return result;
1707416777 }
1707516778
1707616779 IrInstruction *result = ir_build_field_parent_ptr(&ira->new_irb, instruction->base.scope,
1707716780 instruction->base.source_node, type_value, field_name_value, casted_field_ptr, field);
17078 ir_link_new_instruction(result, &instruction->base);
17079 return result_type;
16781 result->value.type = result_type;
16782 return result;
1708016783}
1708116784
1708216785static TypeStructField *validate_byte_offset(IrAnalyze *ira,
......@@ -17121,44 +16824,39 @@ static TypeStructField *validate_byte_offset(IrAnalyze *ira,
1712116824 return field;
1712216825}
1712316826
17124static ZigType *ir_analyze_instruction_byte_offset_of(IrAnalyze *ira,
16827static IrInstruction *ir_analyze_instruction_byte_offset_of(IrAnalyze *ira,
1712516828 IrInstructionByteOffsetOf *instruction)
1712616829{
17127 IrInstruction *type_value = instruction->type_value->other;
16830 IrInstruction *type_value = instruction->type_value->child;
1712816831 if (type_is_invalid(type_value->value.type))
17129 return ira->codegen->builtin_types.entry_invalid;
16832 return ira->codegen->invalid_instruction;
1713016833
17131 IrInstruction *field_name_value = instruction->field_name->other;
16834 IrInstruction *field_name_value = instruction->field_name->child;
1713216835 size_t byte_offset = 0;
1713316836 if (!validate_byte_offset(ira, type_value, field_name_value, &byte_offset))
17134 return ira->codegen->builtin_types.entry_invalid;
16837 return ira->codegen->invalid_instruction;
1713516838
1713616839
17137 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
17138 bigint_init_unsigned(&out_val->data.x_bigint, byte_offset);
17139 return ira->codegen->builtin_types.entry_num_lit_int;
16840 return ir_const_unsigned(ira, &instruction->base, byte_offset);
1714016841}
1714116842
17142static ZigType *ir_analyze_instruction_bit_offset_of(IrAnalyze *ira,
16843static IrInstruction *ir_analyze_instruction_bit_offset_of(IrAnalyze *ira,
1714316844 IrInstructionBitOffsetOf *instruction)
1714416845{
17145 IrInstruction *type_value = instruction->type_value->other;
16846 IrInstruction *type_value = instruction->type_value->child;
1714616847 if (type_is_invalid(type_value->value.type))
17147 return ira->codegen->builtin_types.entry_invalid;
17148 IrInstruction *field_name_value = instruction->field_name->other;
16848 return ira->codegen->invalid_instruction;
16849 IrInstruction *field_name_value = instruction->field_name->child;
1714916850 size_t byte_offset = 0;
1715016851 TypeStructField *field = nullptr;
1715116852 if (!(field = validate_byte_offset(ira, type_value, field_name_value, &byte_offset)))
17152 return ira->codegen->builtin_types.entry_invalid;
16853 return ira->codegen->invalid_instruction;
1715316854
1715416855 size_t bit_offset = byte_offset * 8 + field->bit_offset_in_host;
17155 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
17156 bigint_init_unsigned(&out_val->data.x_bigint, bit_offset);
17157 return ira->codegen->builtin_types.entry_num_lit_int;
16856 return ir_const_unsigned(ira, &instruction->base, bit_offset);
1715816857}
1715916858
17160static void ensure_field_index(ZigType *type, const char *field_name, size_t index)
17161{
16859static void ensure_field_index(ZigType *type, const char *field_name, size_t index) {
1716216860 Buf *field_name_buf;
1716316861
1716416862 assert(type != nullptr && !type_is_invalid(type));
......@@ -17170,8 +16868,8 @@ static void ensure_field_index(ZigType *type, const char *field_name, size_t ind
1717016868
1717116869static ZigType *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, ZigType *root) {
1717216870 Error err;
17173 static ConstExprValue *type_info_var = nullptr;
17174 static ZigType *type_info_type = nullptr;
16871 static ConstExprValue *type_info_var = nullptr; // TODO oops this global variable made it past code review
16872 static ZigType *type_info_type = nullptr; // TODO oops this global variable made it past code review
1717516873 if (type_info_var == nullptr) {
1717616874 type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
1717716875 assert(type_info_var->type->id == ZigTypeIdMetaType);
......@@ -18080,23 +17778,23 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
1808017778 return ErrorNone;
1808117779}
1808217780
18083static ZigType *ir_analyze_instruction_type_info(IrAnalyze *ira,
17781static IrInstruction *ir_analyze_instruction_type_info(IrAnalyze *ira,
1808417782 IrInstructionTypeInfo *instruction)
1808517783{
1808617784 Error err;
18087 IrInstruction *type_value = instruction->type_value->other;
17785 IrInstruction *type_value = instruction->type_value->child;
1808817786 ZigType *type_entry = ir_resolve_type(ira, type_value);
1808917787 if (type_is_invalid(type_entry))
18090 return ira->codegen->builtin_types.entry_invalid;
17788 return ira->codegen->invalid_instruction;
1809117789
1809217790 ZigType *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
1809317791
1809417792 ConstExprValue *payload;
1809517793 if ((err = ir_make_type_info_value(ira, type_entry, &payload)))
18096 return ira->codegen->builtin_types.entry_invalid;
17794 return ira->codegen->invalid_instruction;
1809717795
18098 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18099 out_val->type = result_type;
17796 IrInstruction *result = ir_const(ira, &instruction->base, result_type);
17797 ConstExprValue *out_val = &result->value;
1810017798 bigint_init_unsigned(&out_val->data.x_union.tag, type_id_index(type_entry));
1810117799 out_val->data.x_union.payload = payload;
1810217800
......@@ -18106,66 +17804,65 @@ static ZigType *ir_analyze_instruction_type_info(IrAnalyze *ira,
1810617804 payload->data.x_struct.parent.data.p_union.union_val = out_val;
1810717805 }
1810817806
18109 return result_type;
17807 return result;
1811017808}
1811117809
18112static ZigType *ir_analyze_instruction_type_id(IrAnalyze *ira,
17810static IrInstruction *ir_analyze_instruction_type_id(IrAnalyze *ira,
1811317811 IrInstructionTypeId *instruction)
1811417812{
18115 IrInstruction *type_value = instruction->type_value->other;
17813 IrInstruction *type_value = instruction->type_value->child;
1811617814 ZigType *type_entry = ir_resolve_type(ira, type_value);
1811717815 if (type_is_invalid(type_entry))
18118 return ira->codegen->builtin_types.entry_invalid;
17816 return ira->codegen->invalid_instruction;
1811917817
1812017818 ConstExprValue *var_value = get_builtin_value(ira->codegen, "TypeId");
1812117819 assert(var_value->type->id == ZigTypeIdMetaType);
1812217820 ZigType *result_type = var_value->data.x_type;
1812317821
18124 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18125 bigint_init_unsigned(&out_val->data.x_enum_tag, type_id_index(type_entry));
18126 return result_type;
17822 IrInstruction *result = ir_const(ira, &instruction->base, result_type);
17823 bigint_init_unsigned(&result->value.data.x_enum_tag, type_id_index(type_entry));
17824 return result;
1812717825}
1812817826
18129static ZigType *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ira,
17827static IrInstruction *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ira,
1813017828 IrInstructionSetEvalBranchQuota *instruction)
1813117829{
1813217830 if (ira->new_irb.exec->parent_exec != nullptr && !ira->new_irb.exec->is_generic_instantiation) {
1813317831 ir_add_error(ira, &instruction->base,
1813417832 buf_sprintf("@setEvalBranchQuota must be called from the top of the comptime stack"));
18135 return ira->codegen->builtin_types.entry_invalid;
17833 return ira->codegen->invalid_instruction;
1813617834 }
1813717835
1813817836 uint64_t new_quota;
18139 if (!ir_resolve_usize(ira, instruction->new_quota->other, &new_quota))
18140 return ira->codegen->builtin_types.entry_invalid;
17837 if (!ir_resolve_usize(ira, instruction->new_quota->child, &new_quota))
17838 return ira->codegen->invalid_instruction;
1814117839
1814217840 if (new_quota > ira->new_irb.exec->backward_branch_quota) {
1814317841 ira->new_irb.exec->backward_branch_quota = new_quota;
1814417842 }
1814517843
18146 ir_build_const_from(ira, &instruction->base);
18147 return ira->codegen->builtin_types.entry_void;
17844 return ir_const_void(ira, &instruction->base);
1814817845}
1814917846
18150static ZigType *ir_analyze_instruction_type_name(IrAnalyze *ira, IrInstructionTypeName *instruction) {
18151 IrInstruction *type_value = instruction->type_value->other;
17847static IrInstruction *ir_analyze_instruction_type_name(IrAnalyze *ira, IrInstructionTypeName *instruction) {
17848 IrInstruction *type_value = instruction->type_value->child;
1815217849 ZigType *type_entry = ir_resolve_type(ira, type_value);
1815317850 if (type_is_invalid(type_entry))
18154 return ira->codegen->builtin_types.entry_invalid;
17851 return ira->codegen->invalid_instruction;
1815517852
1815617853 if (!type_entry->cached_const_name_val) {
1815717854 type_entry->cached_const_name_val = create_const_str_lit(ira->codegen, &type_entry->name);
1815817855 }
18159 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18160 copy_const_val(out_val, type_entry->cached_const_name_val, true);
18161 return out_val->type;
17856 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
17857 copy_const_val(&result->value, type_entry->cached_const_name_val, true);
17858 return result;
1816217859}
1816317860
18164static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCImport *instruction) {
17861static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCImport *instruction) {
1816517862 if (ira->codegen->enable_cache) {
1816617863 ir_add_error(ira, &instruction->base,
1816717864 buf_sprintf("TODO @cImport is incompatible with --cache on. The cache system currently is unable to detect subsequent changes in .h files."));
18168 return ira->codegen->builtin_types.entry_invalid;
17865 return ira->codegen->invalid_instruction;
1816917866 }
1817017867
1817117868 AstNode *node = instruction->base.source_node;
......@@ -18176,11 +17873,11 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
1817617873
1817717874 // Execute the C import block like an inline function
1817817875 ZigType *void_type = ira->codegen->builtin_types.entry_void;
18179 IrInstruction *result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type,
17876 IrInstruction *cimport_result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type,
1818017877 ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr,
1818117878 &cimport_scope->buf, block_node, nullptr, nullptr);
18182 if (type_is_invalid(result->value.type))
18183 return ira->codegen->builtin_types.entry_invalid;
17879 if (type_is_invalid(cimport_result->value.type))
17880 return ira->codegen->invalid_instruction;
1818417881
1818517882 find_libc_include_path(ira->codegen);
1818617883
......@@ -18199,7 +17896,7 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
1819917896 if ((err = parse_h_buf(child_import, &errors, &cimport_scope->buf, ira->codegen, node))) {
1820017897 if (err != ErrorCCompileErrors) {
1820117898 ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
18202 return ira->codegen->builtin_types.entry_invalid;
17899 return ira->codegen->invalid_instruction;
1820317900 }
1820417901 }
1820517902
......@@ -18210,7 +17907,7 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
1821017907 err_msg_add_note(parent_err_msg, err_msg);
1821117908 }
1821217909
18213 return ira->codegen->builtin_types.entry_invalid;
17910 return ira->codegen->invalid_instruction;
1821417911 }
1821517912
1821617913 if (ira->codegen->verbose_cimport) {
......@@ -18221,19 +17918,19 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
1822117918
1822217919 scan_decls(ira->codegen, child_import->decls_scope, child_import->root);
1822317920
18224 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18225 out_val->data.x_import = child_import;
18226 return ira->codegen->builtin_types.entry_namespace;
17921 IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_namespace);
17922 result->value.data.x_import = child_import;
17923 return result;
1822717924}
1822817925
18229static ZigType *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCInclude *instruction) {
18230 IrInstruction *name_value = instruction->name->other;
17926static IrInstruction *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCInclude *instruction) {
17927 IrInstruction *name_value = instruction->name->child;
1823117928 if (type_is_invalid(name_value->value.type))
18232 return ira->codegen->builtin_types.entry_invalid;
17929 return ira->codegen->invalid_instruction;
1823317930
1823417931 Buf *include_name = ir_resolve_str(ira, name_value);
1823517932 if (!include_name)
18236 return ira->codegen->builtin_types.entry_invalid;
17933 return ira->codegen->invalid_instruction;
1823717934
1823817935 Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
1823917936 // We check for this error in pass1
......@@ -18241,26 +17938,25 @@ static ZigType *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCI
1824117938
1824217939 buf_appendf(c_import_buf, "#include <%s>\n", buf_ptr(include_name));
1824317940
18244 ir_build_const_from(ira, &instruction->base);
18245 return ira->codegen->builtin_types.entry_void;
17941 return ir_const_void(ira, &instruction->base);
1824617942}
1824717943
18248static ZigType *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDefine *instruction) {
18249 IrInstruction *name = instruction->name->other;
17944static IrInstruction *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDefine *instruction) {
17945 IrInstruction *name = instruction->name->child;
1825017946 if (type_is_invalid(name->value.type))
18251 return ira->codegen->builtin_types.entry_invalid;
17947 return ira->codegen->invalid_instruction;
1825217948
1825317949 Buf *define_name = ir_resolve_str(ira, name);
1825417950 if (!define_name)
18255 return ira->codegen->builtin_types.entry_invalid;
17951 return ira->codegen->invalid_instruction;
1825617952
18257 IrInstruction *value = instruction->value->other;
17953 IrInstruction *value = instruction->value->child;
1825817954 if (type_is_invalid(value->value.type))
18259 return ira->codegen->builtin_types.entry_invalid;
17955 return ira->codegen->invalid_instruction;
1826017956
1826117957 Buf *define_value = ir_resolve_str(ira, value);
1826217958 if (!define_value)
18263 return ira->codegen->builtin_types.entry_invalid;
17959 return ira->codegen->invalid_instruction;
1826417960
1826517961 Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
1826617962 // We check for this error in pass1
......@@ -18268,18 +17964,17 @@ static ZigType *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDe
1826817964
1826917965 buf_appendf(c_import_buf, "#define %s %s\n", buf_ptr(define_name), buf_ptr(define_value));
1827017966
18271 ir_build_const_from(ira, &instruction->base);
18272 return ira->codegen->builtin_types.entry_void;
17967 return ir_const_void(ira, &instruction->base);
1827317968}
1827417969
18275static ZigType *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUndef *instruction) {
18276 IrInstruction *name = instruction->name->other;
17970static IrInstruction *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUndef *instruction) {
17971 IrInstruction *name = instruction->name->child;
1827717972 if (type_is_invalid(name->value.type))
18278 return ira->codegen->builtin_types.entry_invalid;
17973 return ira->codegen->invalid_instruction;
1827917974
1828017975 Buf *undef_name = ir_resolve_str(ira, name);
1828117976 if (!undef_name)
18282 return ira->codegen->builtin_types.entry_invalid;
17977 return ira->codegen->invalid_instruction;
1828317978
1828417979 Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
1828517980 // We check for this error in pass1
......@@ -18287,18 +17982,17 @@ static ZigType *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUnd
1828717982
1828817983 buf_appendf(c_import_buf, "#undef %s\n", buf_ptr(undef_name));
1828917984
18290 ir_build_const_from(ira, &instruction->base);
18291 return ira->codegen->builtin_types.entry_void;
17985 return ir_const_void(ira, &instruction->base);
1829217986}
1829317987
18294static ZigType *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionEmbedFile *instruction) {
18295 IrInstruction *name = instruction->name->other;
17988static IrInstruction *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionEmbedFile *instruction) {
17989 IrInstruction *name = instruction->name->child;
1829617990 if (type_is_invalid(name->value.type))
18297 return ira->codegen->builtin_types.entry_invalid;
17991 return ira->codegen->invalid_instruction;
1829817992
1829917993 Buf *rel_file_path = ir_resolve_str(ira, name);
1830017994 if (!rel_file_path)
18301 return ira->codegen->builtin_types.entry_invalid;
17995 return ira->codegen->invalid_instruction;
1830217996
1830317997 ImportTableEntry *import = get_scope_import(instruction->base.scope);
1830417998 // figure out absolute path to resource
......@@ -18318,85 +18012,86 @@ static ZigType *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionE
1831818012 if ((err = file_fetch(ira->codegen, file_path, file_contents))) {
1831918013 if (err == ErrorFileNotFound) {
1832018014 ir_add_error(ira, instruction->name, buf_sprintf("unable to find '%s'", buf_ptr(file_path)));
18321 return ira->codegen->builtin_types.entry_invalid;
18015 return ira->codegen->invalid_instruction;
1832218016 } else {
1832318017 ir_add_error(ira, instruction->name, buf_sprintf("unable to open '%s': %s", buf_ptr(file_path), err_str(err)));
18324 return ira->codegen->builtin_types.entry_invalid;
18018 return ira->codegen->invalid_instruction;
1832518019 }
1832618020 }
1832718021
18328 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18329 init_const_str_lit(ira->codegen, out_val, file_contents);
18330
18331 return get_array_type(ira->codegen, ira->codegen->builtin_types.entry_u8, buf_len(file_contents));
18022 ZigType *result_type = get_array_type(ira->codegen,
18023 ira->codegen->builtin_types.entry_u8, buf_len(file_contents));
18024 IrInstruction *result = ir_const(ira, &instruction->base, result_type);
18025 init_const_str_lit(ira->codegen, &result->value, file_contents);
18026 return result;
1833218027}
1833318028
18334static ZigType *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpxchg *instruction) {
18335 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
18029static IrInstruction *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpxchg *instruction) {
18030 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->child);
1833618031 if (type_is_invalid(operand_type))
18337 return ira->codegen->builtin_types.entry_invalid;
18032 return ira->codegen->invalid_instruction;
1833818033
18339 IrInstruction *ptr = instruction->ptr->other;
18034 IrInstruction *ptr = instruction->ptr->child;
1834018035 if (type_is_invalid(ptr->value.type))
18341 return ira->codegen->builtin_types.entry_invalid;
18036 return ira->codegen->invalid_instruction;
1834218037
1834318038 // TODO let this be volatile
1834418039 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
1834518040 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
1834618041 if (type_is_invalid(casted_ptr->value.type))
18347 return ira->codegen->builtin_types.entry_invalid;
18042 return ira->codegen->invalid_instruction;
1834818043
18349 IrInstruction *cmp_value = instruction->cmp_value->other;
18044 IrInstruction *cmp_value = instruction->cmp_value->child;
1835018045 if (type_is_invalid(cmp_value->value.type))
18351 return ira->codegen->builtin_types.entry_invalid;
18046 return ira->codegen->invalid_instruction;
1835218047
18353 IrInstruction *new_value = instruction->new_value->other;
18048 IrInstruction *new_value = instruction->new_value->child;
1835418049 if (type_is_invalid(new_value->value.type))
18355 return ira->codegen->builtin_types.entry_invalid;
18050 return ira->codegen->invalid_instruction;
1835618051
18357 IrInstruction *success_order_value = instruction->success_order_value->other;
18052 IrInstruction *success_order_value = instruction->success_order_value->child;
1835818053 if (type_is_invalid(success_order_value->value.type))
18359 return ira->codegen->builtin_types.entry_invalid;
18054 return ira->codegen->invalid_instruction;
1836018055
1836118056 AtomicOrder success_order;
1836218057 if (!ir_resolve_atomic_order(ira, success_order_value, &success_order))
18363 return ira->codegen->builtin_types.entry_invalid;
18058 return ira->codegen->invalid_instruction;
1836418059
18365 IrInstruction *failure_order_value = instruction->failure_order_value->other;
18060 IrInstruction *failure_order_value = instruction->failure_order_value->child;
1836618061 if (type_is_invalid(failure_order_value->value.type))
18367 return ira->codegen->builtin_types.entry_invalid;
18062 return ira->codegen->invalid_instruction;
1836818063
1836918064 AtomicOrder failure_order;
1837018065 if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
18371 return ira->codegen->builtin_types.entry_invalid;
18066 return ira->codegen->invalid_instruction;
1837218067
1837318068 IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
1837418069 if (type_is_invalid(casted_cmp_value->value.type))
18375 return ira->codegen->builtin_types.entry_invalid;
18070 return ira->codegen->invalid_instruction;
1837618071
1837718072 IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
1837818073 if (type_is_invalid(casted_new_value->value.type))
18379 return ira->codegen->builtin_types.entry_invalid;
18074 return ira->codegen->invalid_instruction;
1838018075
1838118076 if (success_order < AtomicOrderMonotonic) {
1838218077 ir_add_error(ira, success_order_value,
1838318078 buf_sprintf("success atomic ordering must be Monotonic or stricter"));
18384 return ira->codegen->builtin_types.entry_invalid;
18079 return ira->codegen->invalid_instruction;
1838518080 }
1838618081 if (failure_order < AtomicOrderMonotonic) {
1838718082 ir_add_error(ira, failure_order_value,
1838818083 buf_sprintf("failure atomic ordering must be Monotonic or stricter"));
18389 return ira->codegen->builtin_types.entry_invalid;
18084 return ira->codegen->invalid_instruction;
1839018085 }
1839118086 if (failure_order > success_order) {
1839218087 ir_add_error(ira, failure_order_value,
1839318088 buf_sprintf("failure atomic ordering must be no stricter than success"));
18394 return ira->codegen->builtin_types.entry_invalid;
18089 return ira->codegen->invalid_instruction;
1839518090 }
1839618091 if (failure_order == AtomicOrderRelease || failure_order == AtomicOrderAcqRel) {
1839718092 ir_add_error(ira, failure_order_value,
1839818093 buf_sprintf("failure atomic ordering must not be Release or AcqRel"));
18399 return ira->codegen->builtin_types.entry_invalid;
18094 return ira->codegen->invalid_instruction;
1840018095 }
1840118096
1840218097 if (instr_is_comptime(casted_ptr) && instr_is_comptime(casted_cmp_value) && instr_is_comptime(casted_new_value)) {
......@@ -18407,127 +18102,118 @@ static ZigType *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpx
1840718102 nullptr, casted_ptr, casted_cmp_value, casted_new_value, nullptr, nullptr, instruction->is_weak,
1840818103 operand_type, success_order, failure_order);
1840918104 result->value.type = get_optional_type(ira->codegen, operand_type);
18410 ir_link_new_instruction(result, &instruction->base);
1841118105 ir_add_alloca(ira, result, result->value.type);
18412 return result->value.type;
18106 return result;
1841318107}
1841418108
18415static ZigType *ir_analyze_instruction_fence(IrAnalyze *ira, IrInstructionFence *instruction) {
18416 IrInstruction *order_value = instruction->order_value->other;
18109static IrInstruction *ir_analyze_instruction_fence(IrAnalyze *ira, IrInstructionFence *instruction) {
18110 IrInstruction *order_value = instruction->order_value->child;
1841718111 if (type_is_invalid(order_value->value.type))
18418 return ira->codegen->builtin_types.entry_invalid;
18112 return ira->codegen->invalid_instruction;
1841918113
1842018114 AtomicOrder order;
1842118115 if (!ir_resolve_atomic_order(ira, order_value, &order))
18422 return ira->codegen->builtin_types.entry_invalid;
18116 return ira->codegen->invalid_instruction;
1842318117
18424 ir_build_fence_from(&ira->new_irb, &instruction->base, order_value, order);
18425 return ira->codegen->builtin_types.entry_void;
18118 IrInstruction *result = ir_build_fence(&ira->new_irb,
18119 instruction->base.scope, instruction->base.source_node, order_value, order);
18120 result->value.type = ira->codegen->builtin_types.entry_void;
18121 return result;
1842618122}
1842718123
18428static ZigType *ir_analyze_instruction_truncate(IrAnalyze *ira, IrInstructionTruncate *instruction) {
18429 IrInstruction *dest_type_value = instruction->dest_type->other;
18124static IrInstruction *ir_analyze_instruction_truncate(IrAnalyze *ira, IrInstructionTruncate *instruction) {
18125 IrInstruction *dest_type_value = instruction->dest_type->child;
1843018126 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
1843118127 if (type_is_invalid(dest_type))
18432 return ira->codegen->builtin_types.entry_invalid;
18128 return ira->codegen->invalid_instruction;
1843318129
1843418130 if (dest_type->id != ZigTypeIdInt &&
1843518131 dest_type->id != ZigTypeIdComptimeInt)
1843618132 {
1843718133 ir_add_error(ira, dest_type_value, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
18438 return ira->codegen->builtin_types.entry_invalid;
18134 return ira->codegen->invalid_instruction;
1843918135 }
1844018136
18441 IrInstruction *target = instruction->target->other;
18137 IrInstruction *target = instruction->target->child;
1844218138 ZigType *src_type = target->value.type;
1844318139 if (type_is_invalid(src_type))
18444 return ira->codegen->builtin_types.entry_invalid;
18140 return ira->codegen->invalid_instruction;
1844518141
1844618142 if (src_type->id != ZigTypeIdInt &&
1844718143 src_type->id != ZigTypeIdComptimeInt)
1844818144 {
1844918145 ir_add_error(ira, target, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
18450 return ira->codegen->builtin_types.entry_invalid;
18146 return ira->codegen->invalid_instruction;
1845118147 }
1845218148
1845318149 if (src_type->data.integral.is_signed != dest_type->data.integral.is_signed) {
1845418150 const char *sign_str = dest_type->data.integral.is_signed ? "signed" : "unsigned";
1845518151 ir_add_error(ira, target, buf_sprintf("expected %s integer type, found '%s'", sign_str, buf_ptr(&src_type->name)));
18456 return ira->codegen->builtin_types.entry_invalid;
18152 return ira->codegen->invalid_instruction;
1845718153 } else if (src_type->data.integral.bit_count < dest_type->data.integral.bit_count) {
1845818154 ir_add_error(ira, target, buf_sprintf("type '%s' has fewer bits than destination type '%s'",
1845918155 buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
18460 return ira->codegen->builtin_types.entry_invalid;
18156 return ira->codegen->invalid_instruction;
1846118157 }
1846218158
1846318159 if (target->value.special == ConstValSpecialStatic) {
18464 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18465 bigint_truncate(&out_val->data.x_bigint, &target->value.data.x_bigint, dest_type->data.integral.bit_count,
18466 dest_type->data.integral.is_signed);
18467 return dest_type;
18160 IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
18161 bigint_truncate(&result->value.data.x_bigint, &target->value.data.x_bigint,
18162 dest_type->data.integral.bit_count, dest_type->data.integral.is_signed);
18163 return result;
1846818164 }
1846918165
1847018166 IrInstruction *new_instruction = ir_build_truncate(&ira->new_irb, instruction->base.scope,
1847118167 instruction->base.source_node, dest_type_value, target);
18472 ir_link_new_instruction(new_instruction, &instruction->base);
18473 return dest_type;
18168 new_instruction->value.type = dest_type;
18169 return new_instruction;
1847418170}
1847518171
18476static ZigType *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstructionIntCast *instruction) {
18477 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18172static IrInstruction *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstructionIntCast *instruction) {
18173 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
1847818174 if (type_is_invalid(dest_type))
18479 return ira->codegen->builtin_types.entry_invalid;
18175 return ira->codegen->invalid_instruction;
1848018176
1848118177 if (dest_type->id != ZigTypeIdInt) {
1848218178 ir_add_error(ira, instruction->dest_type, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
18483 return ira->codegen->builtin_types.entry_invalid;
18179 return ira->codegen->invalid_instruction;
1848418180 }
1848518181
18486 IrInstruction *target = instruction->target->other;
18182 IrInstruction *target = instruction->target->child;
1848718183 if (type_is_invalid(target->value.type))
18488 return ira->codegen->builtin_types.entry_invalid;
18184 return ira->codegen->invalid_instruction;
1848918185
1849018186 if (target->value.type->id == ZigTypeIdComptimeInt) {
1849118187 if (ir_num_lit_fits_in_other_type(ira, target, dest_type, true)) {
18492 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type,
18493 CastOpNumLitToConcrete, false);
18494 if (type_is_invalid(result->value.type))
18495 return ira->codegen->builtin_types.entry_invalid;
18496 ir_link_new_instruction(result, &instruction->base);
18497 return dest_type;
18188 return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpNumLitToConcrete, false);
1849818189 } else {
18499 return ira->codegen->builtin_types.entry_invalid;
18190 return ira->codegen->invalid_instruction;
1850018191 }
1850118192 }
1850218193
1850318194 if (target->value.type->id != ZigTypeIdInt) {
1850418195 ir_add_error(ira, instruction->target, buf_sprintf("expected integer type, found '%s'",
1850518196 buf_ptr(&target->value.type->name)));
18506 return ira->codegen->builtin_types.entry_invalid;
18197 return ira->codegen->invalid_instruction;
1850718198 }
1850818199
18509 IrInstruction *result = ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
18510 if (type_is_invalid(result->value.type))
18511 return ira->codegen->builtin_types.entry_invalid;
18512
18513 ir_link_new_instruction(result, &instruction->base);
18514 return dest_type;
18200 return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
1851518201}
1851618202
18517static ZigType *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionFloatCast *instruction) {
18518 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18203static IrInstruction *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionFloatCast *instruction) {
18204 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
1851918205 if (type_is_invalid(dest_type))
18520 return ira->codegen->builtin_types.entry_invalid;
18206 return ira->codegen->invalid_instruction;
1852118207
1852218208 if (dest_type->id != ZigTypeIdFloat) {
1852318209 ir_add_error(ira, instruction->dest_type,
1852418210 buf_sprintf("expected float type, found '%s'", buf_ptr(&dest_type->name)));
18525 return ira->codegen->builtin_types.entry_invalid;
18211 return ira->codegen->invalid_instruction;
1852618212 }
1852718213
18528 IrInstruction *target = instruction->target->other;
18214 IrInstruction *target = instruction->target->child;
1852918215 if (type_is_invalid(target->value.type))
18530 return ira->codegen->builtin_types.entry_invalid;
18216 return ira->codegen->invalid_instruction;
1853118217
1853218218 if (target->value.type->id == ZigTypeIdComptimeInt ||
1853318219 target->value.type->id == ZigTypeIdComptimeFloat)
......@@ -18539,55 +18225,43 @@ static ZigType *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionF
1853918225 } else {
1854018226 op = CastOpNumLitToConcrete;
1854118227 }
18542 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, op, false);
18543 if (type_is_invalid(result->value.type))
18544 return ira->codegen->builtin_types.entry_invalid;
18545 ir_link_new_instruction(result, &instruction->base);
18546 return dest_type;
18228 return ir_resolve_cast(ira, &instruction->base, target, dest_type, op, false);
1854718229 } else {
18548 return ira->codegen->builtin_types.entry_invalid;
18230 return ira->codegen->invalid_instruction;
1854918231 }
1855018232 }
1855118233
1855218234 if (target->value.type->id != ZigTypeIdFloat) {
1855318235 ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
1855418236 buf_ptr(&target->value.type->name)));
18555 return ira->codegen->builtin_types.entry_invalid;
18237 return ira->codegen->invalid_instruction;
1855618238 }
1855718239
18558 IrInstruction *result = ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
18559 if (type_is_invalid(result->value.type))
18560 return ira->codegen->builtin_types.entry_invalid;
18561 ir_link_new_instruction(result, &instruction->base);
18562 return dest_type;
18240 return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
1856318241}
1856418242
18565static ZigType *ir_analyze_instruction_err_set_cast(IrAnalyze *ira, IrInstructionErrSetCast *instruction) {
18566 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18243static IrInstruction *ir_analyze_instruction_err_set_cast(IrAnalyze *ira, IrInstructionErrSetCast *instruction) {
18244 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
1856718245 if (type_is_invalid(dest_type))
18568 return ira->codegen->builtin_types.entry_invalid;
18246 return ira->codegen->invalid_instruction;
1856918247
1857018248 if (dest_type->id != ZigTypeIdErrorSet) {
1857118249 ir_add_error(ira, instruction->dest_type,
1857218250 buf_sprintf("expected error set type, found '%s'", buf_ptr(&dest_type->name)));
18573 return ira->codegen->builtin_types.entry_invalid;
18251 return ira->codegen->invalid_instruction;
1857418252 }
1857518253
18576 IrInstruction *target = instruction->target->other;
18254 IrInstruction *target = instruction->target->child;
1857718255 if (type_is_invalid(target->value.type))
18578 return ira->codegen->builtin_types.entry_invalid;
18256 return ira->codegen->invalid_instruction;
1857918257
1858018258 if (target->value.type->id != ZigTypeIdErrorSet) {
1858118259 ir_add_error(ira, instruction->target,
1858218260 buf_sprintf("expected error set type, found '%s'", buf_ptr(&target->value.type->name)));
18583 return ira->codegen->builtin_types.entry_invalid;
18261 return ira->codegen->invalid_instruction;
1858418262 }
1858518263
18586 IrInstruction *result = ir_analyze_err_set_cast(ira, &instruction->base, target, dest_type);
18587 if (type_is_invalid(result->value.type))
18588 return ira->codegen->builtin_types.entry_invalid;
18589 ir_link_new_instruction(result, &instruction->base);
18590 return dest_type;
18264 return ir_analyze_err_set_cast(ira, &instruction->base, target, dest_type);
1859118265}
1859218266
1859318267static Error resolve_ptr_align(IrAnalyze *ira, ZigType *ty, uint32_t *result_align) {
......@@ -18602,16 +18276,16 @@ static Error resolve_ptr_align(IrAnalyze *ira, ZigType *ty, uint32_t *result_ali
1860218276 return ErrorNone;
1860318277}
1860418278
18605static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionFromBytes *instruction) {
18279static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionFromBytes *instruction) {
1860618280 Error err;
1860718281
18608 ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->other);
18282 ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->child);
1860918283 if (type_is_invalid(dest_child_type))
18610 return ira->codegen->builtin_types.entry_invalid;
18284 return ira->codegen->invalid_instruction;
1861118285
18612 IrInstruction *target = instruction->target->other;
18286 IrInstruction *target = instruction->target->child;
1861318287 if (type_is_invalid(target->value.type))
18614 return ira->codegen->builtin_types.entry_invalid;
18288 return ira->codegen->invalid_instruction;
1861518289
1861618290 bool src_ptr_const;
1861718291 bool src_ptr_volatile;
......@@ -18621,26 +18295,26 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
1862118295 src_ptr_volatile = target->value.type->data.pointer.is_volatile;
1862218296
1862318297 if ((err = resolve_ptr_align(ira, target->value.type, &src_ptr_align)))
18624 return ira->codegen->builtin_types.entry_invalid;
18298 return ira->codegen->invalid_instruction;
1862518299 } else if (is_slice(target->value.type)) {
1862618300 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
1862718301 src_ptr_const = src_ptr_type->data.pointer.is_const;
1862818302 src_ptr_volatile = src_ptr_type->data.pointer.is_volatile;
1862918303
1863018304 if ((err = resolve_ptr_align(ira, src_ptr_type, &src_ptr_align)))
18631 return ira->codegen->builtin_types.entry_invalid;
18305 return ira->codegen->invalid_instruction;
1863218306 } else {
1863318307 src_ptr_const = true;
1863418308 src_ptr_volatile = false;
1863518309
1863618310 if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusAlignmentKnown)))
18637 return ira->codegen->builtin_types.entry_invalid;
18311 return ira->codegen->invalid_instruction;
1863818312
1863918313 src_ptr_align = get_abi_alignment(ira->codegen, target->value.type);
1864018314 }
1864118315
1864218316 if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusSizeKnown)))
18643 return ira->codegen->builtin_types.entry_invalid;
18317 return ira->codegen->invalid_instruction;
1864418318
1864518319 ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
1864618320 src_ptr_const, src_ptr_volatile, PtrLenUnknown,
......@@ -18654,7 +18328,7 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
1865418328
1865518329 IrInstruction *casted_value = ir_implicit_cast(ira, target, u8_slice);
1865618330 if (type_is_invalid(casted_value->value.type))
18657 return ira->codegen->builtin_types.entry_invalid;
18331 return ira->codegen->invalid_instruction;
1865818332
1865918333 bool have_known_len = false;
1866018334 uint64_t known_len;
......@@ -18662,7 +18336,7 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
1866218336 if (instr_is_comptime(casted_value)) {
1866318337 ConstExprValue *val = ir_resolve_const(ira, casted_value, UndefBad);
1866418338 if (!val)
18665 return ira->codegen->builtin_types.entry_invalid;
18339 return ira->codegen->invalid_instruction;
1866618340
1866718341 ConstExprValue *len_val = &val->data.x_struct.fields[slice_len_index];
1866818342 if (value_is_comptime(len_val)) {
......@@ -18686,96 +18360,84 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
1868618360 add_error_note(ira->codegen, msg, instruction->dest_child_type->source_node,
1868718361 buf_sprintf("%s has size %" ZIG_PRI_u64 "; remaining bytes: %" ZIG_PRI_u64,
1868818362 buf_ptr(&dest_child_type->name), child_type_size, remainder));
18689 return ira->codegen->builtin_types.entry_invalid;
18363 return ira->codegen->invalid_instruction;
1869018364 }
1869118365 }
1869218366
18693 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, casted_value, dest_slice_type, CastOpResizeSlice, true);
18694 ir_link_new_instruction(result, &instruction->base);
18695 return dest_slice_type;
18367 return ir_resolve_cast(ira, &instruction->base, casted_value, dest_slice_type, CastOpResizeSlice, true);
1869618368}
1869718369
18698static ZigType *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstructionToBytes *instruction) {
18370static IrInstruction *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstructionToBytes *instruction) {
1869918371 Error err;
1870018372
18701 IrInstruction *target = instruction->target->other;
18373 IrInstruction *target = instruction->target->child;
1870218374 if (type_is_invalid(target->value.type))
18703 return ira->codegen->builtin_types.entry_invalid;
18375 return ira->codegen->invalid_instruction;
1870418376
1870518377 if (!is_slice(target->value.type)) {
1870618378 ir_add_error(ira, instruction->target,
1870718379 buf_sprintf("expected slice, found '%s'", buf_ptr(&target->value.type->name)));
18708 return ira->codegen->builtin_types.entry_invalid;
18380 return ira->codegen->invalid_instruction;
1870918381 }
1871018382
1871118383 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
1871218384
1871318385 uint32_t alignment;
1871418386 if ((err = resolve_ptr_align(ira, src_ptr_type, &alignment)))
18715 return ira->codegen->builtin_types.entry_invalid;
18387 return ira->codegen->invalid_instruction;
1871618388
1871718389 ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
1871818390 src_ptr_type->data.pointer.is_const, src_ptr_type->data.pointer.is_volatile, PtrLenUnknown,
1871918391 alignment, 0, 0);
1872018392 ZigType *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
1872118393
18722 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_slice_type, CastOpResizeSlice, true);
18723 ir_link_new_instruction(result, &instruction->base);
18724 return dest_slice_type;
18394 return ir_resolve_cast(ira, &instruction->base, target, dest_slice_type, CastOpResizeSlice, true);
1872518395}
1872618396
18727static ZigType *ir_analyze_instruction_int_to_float(IrAnalyze *ira, IrInstructionIntToFloat *instruction) {
18728 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18397static IrInstruction *ir_analyze_instruction_int_to_float(IrAnalyze *ira, IrInstructionIntToFloat *instruction) {
18398 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
1872918399 if (type_is_invalid(dest_type))
18730 return ira->codegen->builtin_types.entry_invalid;
18400 return ira->codegen->invalid_instruction;
1873118401
18732 IrInstruction *target = instruction->target->other;
18402 IrInstruction *target = instruction->target->child;
1873318403 if (type_is_invalid(target->value.type))
18734 return ira->codegen->builtin_types.entry_invalid;
18404 return ira->codegen->invalid_instruction;
1873518405
1873618406 if (target->value.type->id != ZigTypeIdInt && target->value.type->id != ZigTypeIdComptimeInt) {
1873718407 ir_add_error(ira, instruction->target, buf_sprintf("expected int type, found '%s'",
1873818408 buf_ptr(&target->value.type->name)));
18739 return ira->codegen->builtin_types.entry_invalid;
18409 return ira->codegen->invalid_instruction;
1874018410 }
1874118411
18742 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpIntToFloat, false);
18743 ir_link_new_instruction(result, &instruction->base);
18744 return dest_type;
18412 return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpIntToFloat, false);
1874518413}
1874618414
18747static ZigType *ir_analyze_instruction_float_to_int(IrAnalyze *ira, IrInstructionFloatToInt *instruction) {
18748 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
18415static IrInstruction *ir_analyze_instruction_float_to_int(IrAnalyze *ira, IrInstructionFloatToInt *instruction) {
18416 ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
1874918417 if (type_is_invalid(dest_type))
18750 return ira->codegen->builtin_types.entry_invalid;
18418 return ira->codegen->invalid_instruction;
1875118419
18752 IrInstruction *target = instruction->target->other;
18420 IrInstruction *target = instruction->target->child;
1875318421 if (type_is_invalid(target->value.type))
18754 return ira->codegen->builtin_types.entry_invalid;
18422 return ira->codegen->invalid_instruction;
1875518423
1875618424 if (target->value.type->id == ZigTypeIdComptimeInt) {
18757 IrInstruction *casted_value = ir_implicit_cast(ira, target, dest_type);
18758 if (type_is_invalid(casted_value->value.type))
18759 return ira->codegen->builtin_types.entry_invalid;
18760 ir_link_new_instruction(casted_value, &instruction->base);
18761 return casted_value->value.type;
18425 return ir_implicit_cast(ira, target, dest_type);
1876218426 }
1876318427
1876418428 if (target->value.type->id != ZigTypeIdFloat && target->value.type->id != ZigTypeIdComptimeFloat) {
1876518429 ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
1876618430 buf_ptr(&target->value.type->name)));
18767 return ira->codegen->builtin_types.entry_invalid;
18431 return ira->codegen->invalid_instruction;
1876818432 }
1876918433
18770 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpFloatToInt, false);
18771 ir_link_new_instruction(result, &instruction->base);
18772 return dest_type;
18434 return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpFloatToInt, false);
1877318435}
1877418436
18775static ZigType *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionErrToInt *instruction) {
18776 IrInstruction *target = instruction->target->other;
18437static IrInstruction *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionErrToInt *instruction) {
18438 IrInstruction *target = instruction->target->child;
1877718439 if (type_is_invalid(target->value.type))
18778 return ira->codegen->builtin_types.entry_invalid;
18440 return ira->codegen->invalid_instruction;
1877918441
1878018442 IrInstruction *casted_target;
1878118443 if (target->value.type->id == ZigTypeIdErrorSet) {
......@@ -18783,110 +18445,100 @@ static ZigType *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionE
1878318445 } else {
1878418446 casted_target = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_global_error_set);
1878518447 if (type_is_invalid(casted_target->value.type))
18786 return ira->codegen->builtin_types.entry_invalid;
18448 return ira->codegen->invalid_instruction;
1878718449 }
1878818450
18789 IrInstruction *result = ir_analyze_err_to_int(ira, &instruction->base, casted_target, ira->codegen->err_tag_type);
18790 ir_link_new_instruction(result, &instruction->base);
18791 return result->value.type;
18451 return ir_analyze_err_to_int(ira, &instruction->base, casted_target, ira->codegen->err_tag_type);
1879218452}
1879318453
18794static ZigType *ir_analyze_instruction_int_to_err(IrAnalyze *ira, IrInstructionIntToErr *instruction) {
18795 IrInstruction *target = instruction->target->other;
18454static IrInstruction *ir_analyze_instruction_int_to_err(IrAnalyze *ira, IrInstructionIntToErr *instruction) {
18455 IrInstruction *target = instruction->target->child;
1879618456 if (type_is_invalid(target->value.type))
18797 return ira->codegen->builtin_types.entry_invalid;
18457 return ira->codegen->invalid_instruction;
1879818458
1879918459 IrInstruction *casted_target = ir_implicit_cast(ira, target, ira->codegen->err_tag_type);
1880018460 if (type_is_invalid(casted_target->value.type))
18801 return ira->codegen->builtin_types.entry_invalid;
18461 return ira->codegen->invalid_instruction;
1880218462
18803 IrInstruction *result = ir_analyze_int_to_err(ira, &instruction->base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
18804 ir_link_new_instruction(result, &instruction->base);
18805 return result->value.type;
18463 return ir_analyze_int_to_err(ira, &instruction->base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
1880618464}
1880718465
18808static ZigType *ir_analyze_instruction_bool_to_int(IrAnalyze *ira, IrInstructionBoolToInt *instruction) {
18809 IrInstruction *target = instruction->target->other;
18466static IrInstruction *ir_analyze_instruction_bool_to_int(IrAnalyze *ira, IrInstructionBoolToInt *instruction) {
18467 IrInstruction *target = instruction->target->child;
1881018468 if (type_is_invalid(target->value.type))
18811 return ira->codegen->builtin_types.entry_invalid;
18469 return ira->codegen->invalid_instruction;
1881218470
1881318471 if (target->value.type->id != ZigTypeIdBool) {
1881418472 ir_add_error(ira, instruction->target, buf_sprintf("expected bool, found '%s'",
1881518473 buf_ptr(&target->value.type->name)));
18816 return ira->codegen->builtin_types.entry_invalid;
18474 return ira->codegen->invalid_instruction;
1881718475 }
1881818476
1881918477 if (instr_is_comptime(target)) {
1882018478 bool is_true;
1882118479 if (!ir_resolve_bool(ira, target, &is_true))
18822 return ira->codegen->builtin_types.entry_invalid;
18480 return ira->codegen->invalid_instruction;
1882318481
18824 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18825 bigint_init_unsigned(&out_val->data.x_bigint, is_true ? 1 : 0);
18826 return ira->codegen->builtin_types.entry_num_lit_int;
18482 return ir_const_unsigned(ira, &instruction->base, is_true ? 1 : 0);
1882718483 }
1882818484
1882918485 ZigType *u1_type = get_int_type(ira->codegen, false, 1);
18830 IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt, false);
18831 ir_link_new_instruction(result, &instruction->base);
18832 return u1_type;
18486 return ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt, false);
1883318487}
1883418488
18835static ZigType *ir_analyze_instruction_int_type(IrAnalyze *ira, IrInstructionIntType *instruction) {
18836 IrInstruction *is_signed_value = instruction->is_signed->other;
18489static IrInstruction *ir_analyze_instruction_int_type(IrAnalyze *ira, IrInstructionIntType *instruction) {
18490 IrInstruction *is_signed_value = instruction->is_signed->child;
1883718491 bool is_signed;
1883818492 if (!ir_resolve_bool(ira, is_signed_value, &is_signed))
18839 return ira->codegen->builtin_types.entry_invalid;
18493 return ira->codegen->invalid_instruction;
1884018494
18841 IrInstruction *bit_count_value = instruction->bit_count->other;
18495 IrInstruction *bit_count_value = instruction->bit_count->child;
1884218496 uint64_t bit_count;
1884318497 if (!ir_resolve_unsigned(ira, bit_count_value, ira->codegen->builtin_types.entry_u32, &bit_count))
18844 return ira->codegen->builtin_types.entry_invalid;
18498 return ira->codegen->invalid_instruction;
1884518499
18846 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18847 out_val->data.x_type = get_int_type(ira->codegen, is_signed, (uint32_t)bit_count);
18848 return ira->codegen->builtin_types.entry_type;
18500 return ir_const_type(ira, &instruction->base, get_int_type(ira->codegen, is_signed, (uint32_t)bit_count));
1884918501}
1885018502
18851static ZigType *ir_analyze_instruction_bool_not(IrAnalyze *ira, IrInstructionBoolNot *instruction) {
18852 IrInstruction *value = instruction->value->other;
18503static IrInstruction *ir_analyze_instruction_bool_not(IrAnalyze *ira, IrInstructionBoolNot *instruction) {
18504 IrInstruction *value = instruction->value->child;
1885318505 if (type_is_invalid(value->value.type))
18854 return ira->codegen->builtin_types.entry_invalid;
18506 return ira->codegen->invalid_instruction;
1885518507
1885618508 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
1885718509
1885818510 IrInstruction *casted_value = ir_implicit_cast(ira, value, bool_type);
1885918511 if (type_is_invalid(casted_value->value.type))
18860 return ira->codegen->builtin_types.entry_invalid;
18512 return ira->codegen->invalid_instruction;
1886118513
1886218514 if (instr_is_comptime(casted_value)) {
1886318515 ConstExprValue *value = ir_resolve_const(ira, casted_value, UndefBad);
1886418516 if (value == nullptr)
18865 return ira->codegen->builtin_types.entry_invalid;
18517 return ira->codegen->invalid_instruction;
1886618518
18867 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18868 out_val->data.x_bool = !value->data.x_bool;
18869 return bool_type;
18519 return ir_const_bool(ira, &instruction->base, !value->data.x_bool);
1887018520 }
1887118521
18872 ir_build_bool_not_from(&ira->new_irb, &instruction->base, casted_value);
18873 return bool_type;
18522 IrInstruction *result = ir_build_bool_not(&ira->new_irb, instruction->base.scope,
18523 instruction->base.source_node, casted_value);
18524 result->value.type = bool_type;
18525 return result;
1887418526}
1887518527
18876static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemset *instruction) {
18528static IrInstruction *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemset *instruction) {
1887718529 Error err;
1887818530
18879 IrInstruction *dest_ptr = instruction->dest_ptr->other;
18531 IrInstruction *dest_ptr = instruction->dest_ptr->child;
1888018532 if (type_is_invalid(dest_ptr->value.type))
18881 return ira->codegen->builtin_types.entry_invalid;
18533 return ira->codegen->invalid_instruction;
1888218534
18883 IrInstruction *byte_value = instruction->byte->other;
18535 IrInstruction *byte_value = instruction->byte->child;
1888418536 if (type_is_invalid(byte_value->value.type))
18885 return ira->codegen->builtin_types.entry_invalid;
18537 return ira->codegen->invalid_instruction;
1888618538
18887 IrInstruction *count_value = instruction->count->other;
18539 IrInstruction *count_value = instruction->count->child;
1888818540 if (type_is_invalid(count_value->value.type))
18889 return ira->codegen->builtin_types.entry_invalid;
18541 return ira->codegen->invalid_instruction;
1889018542
1889118543 ZigType *dest_uncasted_type = dest_ptr->value.type;
1889218544 bool dest_is_volatile = (dest_uncasted_type->id == ZigTypeIdPointer) &&
......@@ -18897,7 +18549,7 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
1889718549 uint32_t dest_align;
1889818550 if (dest_uncasted_type->id == ZigTypeIdPointer) {
1889918551 if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
18900 return ira->codegen->builtin_types.entry_invalid;
18552 return ira->codegen->invalid_instruction;
1890118553 } else {
1890218554 dest_align = get_abi_alignment(ira->codegen, u8);
1890318555 }
......@@ -18906,15 +18558,15 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
1890618558
1890718559 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
1890818560 if (type_is_invalid(casted_dest_ptr->value.type))
18909 return ira->codegen->builtin_types.entry_invalid;
18561 return ira->codegen->invalid_instruction;
1891018562
1891118563 IrInstruction *casted_byte = ir_implicit_cast(ira, byte_value, u8);
1891218564 if (type_is_invalid(casted_byte->value.type))
18913 return ira->codegen->builtin_types.entry_invalid;
18565 return ira->codegen->invalid_instruction;
1891418566
1891518567 IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
1891618568 if (type_is_invalid(casted_count->value.type))
18917 return ira->codegen->builtin_types.entry_invalid;
18569 return ira->codegen->invalid_instruction;
1891818570
1891918571 if (casted_dest_ptr->value.special == ConstValSpecialStatic &&
1892018572 casted_byte->value.special == ConstValSpecialStatic &&
......@@ -18956,7 +18608,7 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
1895618608 size_t end = start + count;
1895718609 if (end > bound_end) {
1895818610 ir_add_error(ira, count_value, buf_sprintf("out of bounds pointer access"));
18959 return ira->codegen->builtin_types.entry_invalid;
18611 return ira->codegen->invalid_instruction;
1896018612 }
1896118613
1896218614 ConstExprValue *byte_val = &casted_byte->value;
......@@ -18964,28 +18616,29 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
1896418616 dest_elements[i] = *byte_val;
1896518617 }
1896618618
18967 ir_build_const_from(ira, &instruction->base);
18968 return ira->codegen->builtin_types.entry_void;
18619 return ir_const_void(ira, &instruction->base);
1896918620 }
1897018621
18971 ir_build_memset_from(&ira->new_irb, &instruction->base, casted_dest_ptr, casted_byte, casted_count);
18972 return ira->codegen->builtin_types.entry_void;
18622 IrInstruction *result = ir_build_memset(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
18623 casted_dest_ptr, casted_byte, casted_count);
18624 result->value.type = ira->codegen->builtin_types.entry_void;
18625 return result;
1897318626}
1897418627
18975static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcpy *instruction) {
18628static IrInstruction *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcpy *instruction) {
1897618629 Error err;
1897718630
18978 IrInstruction *dest_ptr = instruction->dest_ptr->other;
18631 IrInstruction *dest_ptr = instruction->dest_ptr->child;
1897918632 if (type_is_invalid(dest_ptr->value.type))
18980 return ira->codegen->builtin_types.entry_invalid;
18633 return ira->codegen->invalid_instruction;
1898118634
18982 IrInstruction *src_ptr = instruction->src_ptr->other;
18635 IrInstruction *src_ptr = instruction->src_ptr->child;
1898318636 if (type_is_invalid(src_ptr->value.type))
18984 return ira->codegen->builtin_types.entry_invalid;
18637 return ira->codegen->invalid_instruction;
1898518638
18986 IrInstruction *count_value = instruction->count->other;
18639 IrInstruction *count_value = instruction->count->child;
1898718640 if (type_is_invalid(count_value->value.type))
18988 return ira->codegen->builtin_types.entry_invalid;
18641 return ira->codegen->invalid_instruction;
1898918642
1899018643 ZigType *u8 = ira->codegen->builtin_types.entry_u8;
1899118644 ZigType *dest_uncasted_type = dest_ptr->value.type;
......@@ -18998,7 +18651,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1899818651 uint32_t dest_align;
1899918652 if (dest_uncasted_type->id == ZigTypeIdPointer) {
1900018653 if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
19001 return ira->codegen->builtin_types.entry_invalid;
18654 return ira->codegen->invalid_instruction;
1900218655 } else {
1900318656 dest_align = get_abi_alignment(ira->codegen, u8);
1900418657 }
......@@ -19006,7 +18659,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1900618659 uint32_t src_align;
1900718660 if (src_uncasted_type->id == ZigTypeIdPointer) {
1900818661 if ((err = resolve_ptr_align(ira, src_uncasted_type, &src_align)))
19009 return ira->codegen->builtin_types.entry_invalid;
18662 return ira->codegen->invalid_instruction;
1901018663 } else {
1901118664 src_align = get_abi_alignment(ira->codegen, u8);
1901218665 }
......@@ -19019,15 +18672,15 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1901918672
1902018673 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
1902118674 if (type_is_invalid(casted_dest_ptr->value.type))
19022 return ira->codegen->builtin_types.entry_invalid;
18675 return ira->codegen->invalid_instruction;
1902318676
1902418677 IrInstruction *casted_src_ptr = ir_implicit_cast(ira, src_ptr, u8_ptr_const);
1902518678 if (type_is_invalid(casted_src_ptr->value.type))
19026 return ira->codegen->builtin_types.entry_invalid;
18679 return ira->codegen->invalid_instruction;
1902718680
1902818681 IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
1902918682 if (type_is_invalid(casted_count->value.type))
19030 return ira->codegen->builtin_types.entry_invalid;
18683 return ira->codegen->invalid_instruction;
1903118684
1903218685 if (casted_dest_ptr->value.special == ConstValSpecialStatic &&
1903318686 casted_src_ptr->value.special == ConstValSpecialStatic &&
......@@ -19068,7 +18721,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1906818721
1906918722 if (dest_start + count > dest_end) {
1907018723 ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
19071 return ira->codegen->builtin_types.entry_invalid;
18724 return ira->codegen->invalid_instruction;
1907218725 }
1907318726
1907418727 ConstExprValue *src_ptr_val = &casted_src_ptr->value;
......@@ -19104,7 +18757,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1910418757
1910518758 if (src_start + count > src_end) {
1910618759 ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
19107 return ira->codegen->builtin_types.entry_invalid;
18760 return ira->codegen->invalid_instruction;
1910818761 }
1910918762
1911018763 // TODO check for noalias violations - this should be generalized to work for any function
......@@ -19113,40 +18766,41 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
1911318766 dest_elements[dest_start + i] = src_elements[src_start + i];
1911418767 }
1911518768
19116 ir_build_const_from(ira, &instruction->base);
19117 return ira->codegen->builtin_types.entry_void;
18769 return ir_const_void(ira, &instruction->base);
1911818770 }
1911918771
19120 ir_build_memcpy_from(&ira->new_irb, &instruction->base, casted_dest_ptr, casted_src_ptr, casted_count);
19121 return ira->codegen->builtin_types.entry_void;
18772 IrInstruction *result = ir_build_memcpy(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
18773 casted_dest_ptr, casted_src_ptr, casted_count);
18774 result->value.type = ira->codegen->builtin_types.entry_void;
18775 return result;
1912218776}
1912318777
19124static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice *instruction) {
19125 IrInstruction *ptr_ptr = instruction->ptr->other;
18778static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice *instruction) {
18779 IrInstruction *ptr_ptr = instruction->ptr->child;
1912618780 if (type_is_invalid(ptr_ptr->value.type))
19127 return ira->codegen->builtin_types.entry_invalid;
18781 return ira->codegen->invalid_instruction;
1912818782
1912918783 ZigType *ptr_type = ptr_ptr->value.type;
1913018784 assert(ptr_type->id == ZigTypeIdPointer);
1913118785 ZigType *array_type = ptr_type->data.pointer.child_type;
1913218786
19133 IrInstruction *start = instruction->start->other;
18787 IrInstruction *start = instruction->start->child;
1913418788 if (type_is_invalid(start->value.type))
19135 return ira->codegen->builtin_types.entry_invalid;
18789 return ira->codegen->invalid_instruction;
1913618790
1913718791 ZigType *usize = ira->codegen->builtin_types.entry_usize;
1913818792 IrInstruction *casted_start = ir_implicit_cast(ira, start, usize);
1913918793 if (type_is_invalid(casted_start->value.type))
19140 return ira->codegen->builtin_types.entry_invalid;
18794 return ira->codegen->invalid_instruction;
1914118795
1914218796 IrInstruction *end;
1914318797 if (instruction->end) {
19144 end = instruction->end->other;
18798 end = instruction->end->child;
1914518799 if (type_is_invalid(end->value.type))
19146 return ira->codegen->builtin_types.entry_invalid;
18800 return ira->codegen->invalid_instruction;
1914718801 end = ir_implicit_cast(ira, end, usize);
1914818802 if (type_is_invalid(end->value.type))
19149 return ira->codegen->builtin_types.entry_invalid;
18803 return ira->codegen->invalid_instruction;
1915018804 } else {
1915118805 end = nullptr;
1915218806 }
......@@ -19174,13 +18828,13 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1917418828 return_type = get_slice_type(ira->codegen, slice_ptr_type);
1917518829 } else {
1917618830 ir_add_error(ira, &instruction->base, buf_sprintf("slice of single-item pointer"));
19177 return ira->codegen->builtin_types.entry_invalid;
18831 return ira->codegen->invalid_instruction;
1917818832 }
1917918833 } else {
1918018834 return_type = get_slice_type(ira->codegen, array_type);
1918118835 if (!end) {
1918218836 ir_add_error(ira, &instruction->base, buf_sprintf("slice of pointer must include end value"));
19183 return ira->codegen->builtin_types.entry_invalid;
18837 return ira->codegen->invalid_instruction;
1918418838 }
1918518839 }
1918618840 } else if (is_slice(array_type)) {
......@@ -19189,7 +18843,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1918918843 } else {
1919018844 ir_add_error(ira, &instruction->base,
1919118845 buf_sprintf("slice of non-array type '%s'", buf_ptr(&array_type->name)));
19192 return ira->codegen->builtin_types.entry_invalid;
18846 return ira->codegen->invalid_instruction;
1919318847 }
1919418848
1919518849 if (instr_is_comptime(ptr_ptr) &&
......@@ -19209,18 +18863,18 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1920918863 assert(child_array_type->id == ZigTypeIdArray);
1921018864 parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
1921118865 if (parent_ptr == nullptr)
19212 return ira->codegen->builtin_types.entry_invalid;
18866 return ira->codegen->invalid_instruction;
1921318867
1921418868 array_val = ir_const_ptr_pointee(ira, parent_ptr, instruction->base.source_node);
1921518869 if (array_val == nullptr)
19216 return ira->codegen->builtin_types.entry_invalid;
18870 return ira->codegen->invalid_instruction;
1921718871
1921818872 rel_end = child_array_type->data.array.len;
1921918873 abs_offset = 0;
1922018874 } else {
1922118875 array_val = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
1922218876 if (array_val == nullptr)
19223 return ira->codegen->builtin_types.entry_invalid;
18877 return ira->codegen->invalid_instruction;
1922418878 rel_end = array_type->data.array.len;
1922518879 parent_ptr = nullptr;
1922618880 abs_offset = 0;
......@@ -19229,7 +18883,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1922918883 assert(array_type->data.pointer.ptr_len == PtrLenUnknown);
1923018884 parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
1923118885 if (parent_ptr == nullptr)
19232 return ira->codegen->builtin_types.entry_invalid;
18886 return ira->codegen->invalid_instruction;
1923318887
1923418888 if (parent_ptr->special == ConstValSpecialUndef) {
1923518889 array_val = nullptr;
......@@ -19269,12 +18923,12 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1926918923 } else if (is_slice(array_type)) {
1927018924 ConstExprValue *slice_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
1927118925 if (slice_ptr == nullptr)
19272 return ira->codegen->builtin_types.entry_invalid;
18926 return ira->codegen->invalid_instruction;
1927318927
1927418928 parent_ptr = &slice_ptr->data.x_struct.fields[slice_ptr_index];
1927518929 if (parent_ptr->special == ConstValSpecialUndef) {
1927618930 ir_add_error(ira, &instruction->base, buf_sprintf("slice of undefined"));
19277 return ira->codegen->builtin_types.entry_invalid;
18931 return ira->codegen->invalid_instruction;
1927818932 }
1927918933
1928018934 ConstExprValue *len_val = &slice_ptr->data.x_struct.fields[slice_len_index];
......@@ -19310,7 +18964,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1931018964 uint64_t start_scalar = bigint_as_unsigned(&casted_start->value.data.x_bigint);
1931118965 if (!ptr_is_undef && start_scalar > rel_end) {
1931218966 ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
19313 return ira->codegen->builtin_types.entry_invalid;
18967 return ira->codegen->invalid_instruction;
1931418968 }
1931518969
1931618970 uint64_t end_scalar;
......@@ -19322,19 +18976,20 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1932218976 if (!ptr_is_undef) {
1932318977 if (end_scalar > rel_end) {
1932418978 ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
19325 return ira->codegen->builtin_types.entry_invalid;
18979 return ira->codegen->invalid_instruction;
1932618980 }
1932718981 if (start_scalar > end_scalar) {
1932818982 ir_add_error(ira, &instruction->base, buf_sprintf("slice start is greater than end"));
19329 return ira->codegen->builtin_types.entry_invalid;
18983 return ira->codegen->invalid_instruction;
1933018984 }
1933118985 }
1933218986 if (ptr_is_undef && start_scalar != end_scalar) {
1933318987 ir_add_error(ira, &instruction->base, buf_sprintf("non-zero length slice of undefined pointer"));
19334 return ira->codegen->builtin_types.entry_invalid;
18988 return ira->codegen->invalid_instruction;
1933518989 }
1933618990
19337 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
18991 IrInstruction *result = ir_const(ira, &instruction->base, return_type);
18992 ConstExprValue *out_val = &result->value;
1933818993 out_val->data.x_struct.fields = create_const_vals(2);
1933918994
1934018995 ConstExprValue *ptr_val = &out_val->data.x_struct.fields[slice_ptr_index];
......@@ -19379,29 +19034,30 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
1937919034 ConstExprValue *len_val = &out_val->data.x_struct.fields[slice_len_index];
1938019035 init_const_usize(ira->codegen, len_val, end_scalar - start_scalar);
1938119036
19382 return return_type;
19037 return result;
1938319038 }
1938419039
19385 IrInstruction *new_instruction = ir_build_slice_from(&ira->new_irb, &instruction->base, ptr_ptr,
19386 casted_start, end, instruction->safety_check_on);
19040 IrInstruction *new_instruction = ir_build_slice(&ira->new_irb,
19041 instruction->base.scope, instruction->base.source_node,
19042 ptr_ptr, casted_start, end, instruction->safety_check_on);
19043 new_instruction->value.type = return_type;
1938719044 ir_add_alloca(ira, new_instruction, return_type);
19388
19389 return return_type;
19045 return new_instruction;
1939019046}
1939119047
19392static ZigType *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
19048static IrInstruction *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
1939319049 Error err;
19394 IrInstruction *container = instruction->container->other;
19050 IrInstruction *container = instruction->container->child;
1939519051 if (type_is_invalid(container->value.type))
19396 return ira->codegen->builtin_types.entry_invalid;
19052 return ira->codegen->invalid_instruction;
1939719053 ZigType *container_type = ir_resolve_type(ira, container);
1939819054
1939919055 if ((err = ensure_complete_type(ira->codegen, container_type)))
19400 return ira->codegen->builtin_types.entry_invalid;
19056 return ira->codegen->invalid_instruction;
1940119057
1940219058 uint64_t result;
1940319059 if (type_is_invalid(container_type)) {
19404 return ira->codegen->builtin_types.entry_invalid;
19060 return ira->codegen->invalid_instruction;
1940519061 } else if (container_type->id == ZigTypeIdEnum) {
1940619062 result = container_type->data.enumeration.src_field_count;
1940719063 } else if (container_type->id == ZigTypeIdStruct) {
......@@ -19410,166 +19066,164 @@ static ZigType *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructio
1941019066 result = container_type->data.unionation.src_field_count;
1941119067 } else if (container_type->id == ZigTypeIdErrorSet) {
1941219068 if (!resolve_inferred_error_set(ira->codegen, container_type, instruction->base.source_node)) {
19413 return ira->codegen->builtin_types.entry_invalid;
19069 return ira->codegen->invalid_instruction;
1941419070 }
1941519071 if (type_is_global_error_set(container_type)) {
1941619072 ir_add_error(ira, &instruction->base, buf_sprintf("global error set member count not available at comptime"));
19417 return ira->codegen->builtin_types.entry_invalid;
19073 return ira->codegen->invalid_instruction;
1941819074 }
1941919075 result = container_type->data.error_set.err_count;
1942019076 } else {
1942119077 ir_add_error(ira, &instruction->base, buf_sprintf("no value count available for type '%s'", buf_ptr(&container_type->name)));
19422 return ira->codegen->builtin_types.entry_invalid;
19078 return ira->codegen->invalid_instruction;
1942319079 }
1942419080
19425 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19426 bigint_init_unsigned(&out_val->data.x_bigint, result);
19427 return ira->codegen->builtin_types.entry_num_lit_int;
19081 return ir_const_unsigned(ira, &instruction->base, result);
1942819082}
1942919083
19430static ZigType *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
19084static IrInstruction *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
1943119085 Error err;
19432 IrInstruction *container_type_value = instruction->container_type->other;
19086 IrInstruction *container_type_value = instruction->container_type->child;
1943319087 ZigType *container_type = ir_resolve_type(ira, container_type_value);
1943419088 if (type_is_invalid(container_type))
19435 return ira->codegen->builtin_types.entry_invalid;
19089 return ira->codegen->invalid_instruction;
1943619090
1943719091 if ((err = ensure_complete_type(ira->codegen, container_type)))
19438 return ira->codegen->builtin_types.entry_invalid;
19092 return ira->codegen->invalid_instruction;
1943919093
1944019094
1944119095 uint64_t member_index;
19442 IrInstruction *index_value = instruction->member_index->other;
19096 IrInstruction *index_value = instruction->member_index->child;
1944319097 if (!ir_resolve_usize(ira, index_value, &member_index))
19444 return ira->codegen->builtin_types.entry_invalid;
19098 return ira->codegen->invalid_instruction;
1944519099
1944619100 if (container_type->id == ZigTypeIdStruct) {
1944719101 if (member_index >= container_type->data.structure.src_field_count) {
1944819102 ir_add_error(ira, index_value,
1944919103 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
1945019104 member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
19451 return ira->codegen->builtin_types.entry_invalid;
19105 return ira->codegen->invalid_instruction;
1945219106 }
1945319107 TypeStructField *field = &container_type->data.structure.fields[member_index];
1945419108
19455 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19456 out_val->data.x_type = field->type_entry;
19457 return ira->codegen->builtin_types.entry_type;
19109 return ir_const_type(ira, &instruction->base, field->type_entry);
1945819110 } else if (container_type->id == ZigTypeIdUnion) {
1945919111 if (member_index >= container_type->data.unionation.src_field_count) {
1946019112 ir_add_error(ira, index_value,
1946119113 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
1946219114 member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
19463 return ira->codegen->builtin_types.entry_invalid;
19115 return ira->codegen->invalid_instruction;
1946419116 }
1946519117 TypeUnionField *field = &container_type->data.unionation.fields[member_index];
1946619118
19467 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19468 out_val->data.x_type = field->type_entry;
19469 return ira->codegen->builtin_types.entry_type;
19119 return ir_const_type(ira, &instruction->base, field->type_entry);
1947019120 } else {
1947119121 ir_add_error(ira, container_type_value,
1947219122 buf_sprintf("type '%s' does not support @memberType", buf_ptr(&container_type->name)));
19473 return ira->codegen->builtin_types.entry_invalid;
19123 return ira->codegen->invalid_instruction;
1947419124 }
1947519125}
1947619126
19477static ZigType *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
19127static IrInstruction *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
1947819128 Error err;
19479 IrInstruction *container_type_value = instruction->container_type->other;
19129 IrInstruction *container_type_value = instruction->container_type->child;
1948019130 ZigType *container_type = ir_resolve_type(ira, container_type_value);
1948119131 if (type_is_invalid(container_type))
19482 return ira->codegen->builtin_types.entry_invalid;
19132 return ira->codegen->invalid_instruction;
1948319133
1948419134 if ((err = ensure_complete_type(ira->codegen, container_type)))
19485 return ira->codegen->builtin_types.entry_invalid;
19135 return ira->codegen->invalid_instruction;
1948619136
1948719137 uint64_t member_index;
19488 IrInstruction *index_value = instruction->member_index->other;
19138 IrInstruction *index_value = instruction->member_index->child;
1948919139 if (!ir_resolve_usize(ira, index_value, &member_index))
19490 return ira->codegen->builtin_types.entry_invalid;
19140 return ira->codegen->invalid_instruction;
1949119141
1949219142 if (container_type->id == ZigTypeIdStruct) {
1949319143 if (member_index >= container_type->data.structure.src_field_count) {
1949419144 ir_add_error(ira, index_value,
1949519145 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
1949619146 member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
19497 return ira->codegen->builtin_types.entry_invalid;
19147 return ira->codegen->invalid_instruction;
1949819148 }
1949919149 TypeStructField *field = &container_type->data.structure.fields[member_index];
1950019150
19501 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19502 init_const_str_lit(ira->codegen, out_val, field->name);
19503 return out_val->type;
19151 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
19152 init_const_str_lit(ira->codegen, &result->value, field->name);
19153 return result;
1950419154 } else if (container_type->id == ZigTypeIdEnum) {
1950519155 if (member_index >= container_type->data.enumeration.src_field_count) {
1950619156 ir_add_error(ira, index_value,
1950719157 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
1950819158 member_index, buf_ptr(&container_type->name), container_type->data.enumeration.src_field_count));
19509 return ira->codegen->builtin_types.entry_invalid;
19159 return ira->codegen->invalid_instruction;
1951019160 }
1951119161 TypeEnumField *field = &container_type->data.enumeration.fields[member_index];
1951219162
19513 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19514 init_const_str_lit(ira->codegen, out_val, field->name);
19515 return out_val->type;
19163 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
19164 init_const_str_lit(ira->codegen, &result->value, field->name);
19165 return result;
1951619166 } else if (container_type->id == ZigTypeIdUnion) {
1951719167 if (member_index >= container_type->data.unionation.src_field_count) {
1951819168 ir_add_error(ira, index_value,
1951919169 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
1952019170 member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
19521 return ira->codegen->builtin_types.entry_invalid;
19171 return ira->codegen->invalid_instruction;
1952219172 }
1952319173 TypeUnionField *field = &container_type->data.unionation.fields[member_index];
1952419174
19525 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19526 init_const_str_lit(ira->codegen, out_val, field->name);
19527 return out_val->type;
19175 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
19176 init_const_str_lit(ira->codegen, &result->value, field->name);
19177 return result;
1952819178 } else {
1952919179 ir_add_error(ira, container_type_value,
1953019180 buf_sprintf("type '%s' does not support @memberName", buf_ptr(&container_type->name)));
19531 return ira->codegen->builtin_types.entry_invalid;
19181 return ira->codegen->invalid_instruction;
1953219182 }
1953319183}
1953419184
19535static ZigType *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {
19536 ir_build_breakpoint_from(&ira->new_irb, &instruction->base);
19537 return ira->codegen->builtin_types.entry_void;
19185static IrInstruction *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {
19186 IrInstruction *result = ir_build_breakpoint(&ira->new_irb,
19187 instruction->base.scope, instruction->base.source_node);
19188 result->value.type = ira->codegen->builtin_types.entry_void;
19189 return result;
1953819190}
1953919191
19540static ZigType *ir_analyze_instruction_return_address(IrAnalyze *ira, IrInstructionReturnAddress *instruction) {
19541 ir_build_return_address_from(&ira->new_irb, &instruction->base);
19542
19192static IrInstruction *ir_analyze_instruction_return_address(IrAnalyze *ira, IrInstructionReturnAddress *instruction) {
19193 IrInstruction *result = ir_build_return_address(&ira->new_irb,
19194 instruction->base.scope, instruction->base.source_node);
1954319195 ZigType *u8 = ira->codegen->builtin_types.entry_u8;
1954419196 ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
19545 return u8_ptr_const;
19197 result->value.type = u8_ptr_const;
19198 return result;
1954619199}
1954719200
19548static ZigType *ir_analyze_instruction_frame_address(IrAnalyze *ira, IrInstructionFrameAddress *instruction) {
19549 ir_build_frame_address_from(&ira->new_irb, &instruction->base);
19550
19201static IrInstruction *ir_analyze_instruction_frame_address(IrAnalyze *ira, IrInstructionFrameAddress *instruction) {
19202 IrInstruction *result = ir_build_frame_address(&ira->new_irb,
19203 instruction->base.scope, instruction->base.source_node);
1955119204 ZigType *u8 = ira->codegen->builtin_types.entry_u8;
1955219205 ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
19553 return u8_ptr_const;
19206 result->value.type = u8_ptr_const;
19207 return result;
1955419208}
1955519209
19556static ZigType *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructionHandle *instruction) {
19557 ir_build_handle_from(&ira->new_irb, &instruction->base);
19558
19210static IrInstruction *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructionHandle *instruction) {
19211 IrInstruction *result = ir_build_handle(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
1955919212 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
1956019213 assert(fn_entry != nullptr);
19561 return get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
19214 result->value.type = get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
19215 return result;
1956219216}
1956319217
19564static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
19218static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
1956519219 Error err;
19566 IrInstruction *type_value = instruction->type_value->other;
19220 IrInstruction *type_value = instruction->type_value->child;
1956719221 if (type_is_invalid(type_value->value.type))
19568 return ira->codegen->builtin_types.entry_invalid;
19222 return ira->codegen->invalid_instruction;
1956919223 ZigType *type_entry = ir_resolve_type(ira, type_value);
1957019224
1957119225 if ((err = type_resolve(ira->codegen, type_entry, ResolveStatusAlignmentKnown)))
19572 return ira->codegen->builtin_types.entry_invalid;
19226 return ira->codegen->invalid_instruction;
1957319227
1957419228 switch (type_entry->id) {
1957519229 case ZigTypeIdInvalid:
......@@ -19587,7 +19241,7 @@ static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAli
1958719241 case ZigTypeIdOpaque:
1958819242 ir_add_error(ira, instruction->type_value,
1958919243 buf_sprintf("no align available for type '%s'", buf_ptr(&type_entry->name)));
19590 return ira->codegen->builtin_types.entry_invalid;
19244 return ira->codegen->invalid_instruction;
1959119245 case ZigTypeIdBool:
1959219246 case ZigTypeIdInt:
1959319247 case ZigTypeIdFloat:
......@@ -19603,42 +19257,40 @@ static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAli
1960319257 case ZigTypeIdFn:
1960419258 {
1960519259 uint64_t align_in_bytes = get_abi_alignment(ira->codegen, type_entry);
19606 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19607 bigint_init_unsigned(&out_val->data.x_bigint, align_in_bytes);
19608 return ira->codegen->builtin_types.entry_num_lit_int;
19260 return ir_const_unsigned(ira, &instruction->base, align_in_bytes);
1960919261 }
1961019262 }
1961119263 zig_unreachable();
1961219264}
1961319265
19614static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) {
19266static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) {
1961519267 Error err;
1961619268
19617 IrInstruction *type_value = instruction->type_value->other;
19269 IrInstruction *type_value = instruction->type_value->child;
1961819270 if (type_is_invalid(type_value->value.type))
19619 return ira->codegen->builtin_types.entry_invalid;
19271 return ira->codegen->invalid_instruction;
1962019272
1962119273 ZigType *dest_type = ir_resolve_type(ira, type_value);
1962219274 if (type_is_invalid(dest_type))
19623 return ira->codegen->builtin_types.entry_invalid;
19275 return ira->codegen->invalid_instruction;
1962419276
1962519277 if (dest_type->id != ZigTypeIdInt) {
1962619278 ir_add_error(ira, type_value,
1962719279 buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
19628 return ira->codegen->builtin_types.entry_invalid;
19280 return ira->codegen->invalid_instruction;
1962919281 }
1963019282
19631 IrInstruction *op1 = instruction->op1->other;
19283 IrInstruction *op1 = instruction->op1->child;
1963219284 if (type_is_invalid(op1->value.type))
19633 return ira->codegen->builtin_types.entry_invalid;
19285 return ira->codegen->invalid_instruction;
1963419286
1963519287 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
1963619288 if (type_is_invalid(casted_op1->value.type))
19637 return ira->codegen->builtin_types.entry_invalid;
19289 return ira->codegen->invalid_instruction;
1963819290
19639 IrInstruction *op2 = instruction->op2->other;
19291 IrInstruction *op2 = instruction->op2->child;
1964019292 if (type_is_invalid(op2->value.type))
19641 return ira->codegen->builtin_types.entry_invalid;
19293 return ira->codegen->invalid_instruction;
1964219294
1964319295 IrInstruction *casted_op2;
1964419296 if (instruction->op == IrOverflowOpShl) {
......@@ -19649,17 +19301,17 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
1964919301 casted_op2 = ir_implicit_cast(ira, op2, dest_type);
1965019302 }
1965119303 if (type_is_invalid(casted_op2->value.type))
19652 return ira->codegen->builtin_types.entry_invalid;
19304 return ira->codegen->invalid_instruction;
1965319305
19654 IrInstruction *result_ptr = instruction->result_ptr->other;
19306 IrInstruction *result_ptr = instruction->result_ptr->child;
1965519307 if (type_is_invalid(result_ptr->value.type))
19656 return ira->codegen->builtin_types.entry_invalid;
19308 return ira->codegen->invalid_instruction;
1965719309
1965819310 ZigType *expected_ptr_type;
1965919311 if (result_ptr->value.type->id == ZigTypeIdPointer) {
1966019312 uint32_t alignment;
1966119313 if ((err = resolve_ptr_align(ira, result_ptr->value.type, &alignment)))
19662 return ira->codegen->builtin_types.entry_invalid;
19314 return ira->codegen->invalid_instruction;
1966319315 expected_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_type,
1966419316 false, result_ptr->value.type->data.pointer.is_volatile,
1966519317 PtrLenSingle,
......@@ -19670,18 +19322,17 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
1967019322
1967119323 IrInstruction *casted_result_ptr = ir_implicit_cast(ira, result_ptr, expected_ptr_type);
1967219324 if (type_is_invalid(casted_result_ptr->value.type))
19673 return ira->codegen->builtin_types.entry_invalid;
19325 return ira->codegen->invalid_instruction;
1967419326
1967519327 if (casted_op1->value.special == ConstValSpecialStatic &&
1967619328 casted_op2->value.special == ConstValSpecialStatic &&
1967719329 casted_result_ptr->value.special == ConstValSpecialStatic)
1967819330 {
19679 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
1968019331 BigInt *op1_bigint = &casted_op1->value.data.x_bigint;
1968119332 BigInt *op2_bigint = &casted_op2->value.data.x_bigint;
1968219333 ConstExprValue *pointee_val = ir_const_ptr_pointee(ira, &casted_result_ptr->value, casted_result_ptr->source_node);
1968319334 if (pointee_val == nullptr)
19684 return ira->codegen->builtin_types.entry_invalid;
19335 return ira->codegen->invalid_instruction;
1968519336 BigInt *dest_bigint = &pointee_val->data.x_bigint;
1968619337 switch (instruction->op) {
1968719338 case IrOverflowOpAdd:
......@@ -19697,77 +19348,74 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
1969719348 bigint_shl(dest_bigint, op1_bigint, op2_bigint);
1969819349 break;
1969919350 }
19351 bool result_bool = false;
1970019352 if (!bigint_fits_in_bits(dest_bigint, dest_type->data.integral.bit_count,
1970119353 dest_type->data.integral.is_signed))
1970219354 {
19703 out_val->data.x_bool = true;
19355 result_bool = true;
1970419356 BigInt tmp_bigint;
1970519357 bigint_init_bigint(&tmp_bigint, dest_bigint);
1970619358 bigint_truncate(dest_bigint, &tmp_bigint, dest_type->data.integral.bit_count,
1970719359 dest_type->data.integral.is_signed);
1970819360 }
1970919361 pointee_val->special = ConstValSpecialStatic;
19710 return ira->codegen->builtin_types.entry_bool;
19362 return ir_const_bool(ira, &instruction->base, result_bool);
1971119363 }
1971219364
19713 ir_build_overflow_op_from(&ira->new_irb, &instruction->base, instruction->op, type_value,
19714 casted_op1, casted_op2, casted_result_ptr, dest_type);
19715 return ira->codegen->builtin_types.entry_bool;
19365 IrInstruction *result = ir_build_overflow_op(&ira->new_irb,
19366 instruction->base.scope, instruction->base.source_node,
19367 instruction->op, type_value, casted_op1, casted_op2, casted_result_ptr, dest_type);
19368 result->value.type = ira->codegen->builtin_types.entry_bool;
19369 return result;
1971619370}
1971719371
19718static ZigType *ir_analyze_instruction_test_err(IrAnalyze *ira, IrInstructionTestErr *instruction) {
19719 IrInstruction *value = instruction->value->other;
19372static IrInstruction *ir_analyze_instruction_test_err(IrAnalyze *ira, IrInstructionTestErr *instruction) {
19373 IrInstruction *value = instruction->value->child;
1972019374 if (type_is_invalid(value->value.type))
19721 return ira->codegen->builtin_types.entry_invalid;
19375 return ira->codegen->invalid_instruction;
1972219376
1972319377 ZigType *type_entry = value->value.type;
1972419378 if (type_is_invalid(type_entry)) {
19725 return ira->codegen->builtin_types.entry_invalid;
19379 return ira->codegen->invalid_instruction;
1972619380 } else if (type_entry->id == ZigTypeIdErrorUnion) {
1972719381 if (instr_is_comptime(value)) {
1972819382 ConstExprValue *err_union_val = ir_resolve_const(ira, value, UndefBad);
1972919383 if (!err_union_val)
19730 return ira->codegen->builtin_types.entry_invalid;
19384 return ira->codegen->invalid_instruction;
1973119385
1973219386 if (err_union_val->special != ConstValSpecialRuntime) {
19733 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19734 out_val->data.x_bool = (err_union_val->data.x_err_union.err != nullptr);
19735 return ira->codegen->builtin_types.entry_bool;
19387 return ir_const_bool(ira, &instruction->base, (err_union_val->data.x_err_union.err != nullptr));
1973619388 }
1973719389 }
1973819390
1973919391 ZigType *err_set_type = type_entry->data.error_union.err_set_type;
1974019392 if (!resolve_inferred_error_set(ira->codegen, err_set_type, instruction->base.source_node)) {
19741 return ira->codegen->builtin_types.entry_invalid;
19393 return ira->codegen->invalid_instruction;
1974219394 }
1974319395 if (!type_is_global_error_set(err_set_type) &&
1974419396 err_set_type->data.error_set.err_count == 0)
1974519397 {
1974619398 assert(err_set_type->data.error_set.infer_fn == nullptr);
19747 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19748 out_val->data.x_bool = false;
19749 return ira->codegen->builtin_types.entry_bool;
19399 return ir_const_bool(ira, &instruction->base, false);
1975019400 }
1975119401
19752 ir_build_test_err_from(&ira->new_irb, &instruction->base, value);
19753 return ira->codegen->builtin_types.entry_bool;
19402 IrInstruction *result = ir_build_test_err(&ira->new_irb,
19403 instruction->base.scope, instruction->base.source_node, value);
19404 result->value.type = ira->codegen->builtin_types.entry_bool;
19405 return result;
1975419406 } else if (type_entry->id == ZigTypeIdErrorSet) {
19755 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19756 out_val->data.x_bool = true;
19757 return ira->codegen->builtin_types.entry_bool;
19407 return ir_const_bool(ira, &instruction->base, true);
1975819408 } else {
19759 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19760 out_val->data.x_bool = false;
19761 return ira->codegen->builtin_types.entry_bool;
19409 return ir_const_bool(ira, &instruction->base, false);
1976219410 }
1976319411}
1976419412
19765static ZigType *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
19413static IrInstruction *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
1976619414 IrInstructionUnwrapErrCode *instruction)
1976719415{
19768 IrInstruction *value = instruction->value->other;
19416 IrInstruction *value = instruction->value->child;
1976919417 if (type_is_invalid(value->value.type))
19770 return ira->codegen->builtin_types.entry_invalid;
19418 return ira->codegen->invalid_instruction;
1977119419 ZigType *ptr_type = value->value.type;
1977219420
1977319421 // This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
......@@ -19775,41 +19423,44 @@ static ZigType *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
1977519423
1977619424 ZigType *type_entry = ptr_type->data.pointer.child_type;
1977719425 if (type_is_invalid(type_entry)) {
19778 return ira->codegen->builtin_types.entry_invalid;
19426 return ira->codegen->invalid_instruction;
1977919427 } else if (type_entry->id == ZigTypeIdErrorUnion) {
1978019428 if (instr_is_comptime(value)) {
1978119429 ConstExprValue *ptr_val = ir_resolve_const(ira, value, UndefBad);
1978219430 if (!ptr_val)
19783 return ira->codegen->builtin_types.entry_invalid;
19431 return ira->codegen->invalid_instruction;
1978419432 ConstExprValue *err_union_val = ir_const_ptr_pointee(ira, ptr_val, instruction->base.source_node);
1978519433 if (err_union_val == nullptr)
19786 return ira->codegen->builtin_types.entry_invalid;
19434 return ira->codegen->invalid_instruction;
1978719435 if (err_union_val->special != ConstValSpecialRuntime) {
1978819436 ErrorTableEntry *err = err_union_val->data.x_err_union.err;
1978919437 assert(err);
1979019438
19791 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19792 out_val->data.x_err_set = err;
19793 return type_entry->data.error_union.err_set_type;
19439 IrInstruction *result = ir_const(ira, &instruction->base,
19440 type_entry->data.error_union.err_set_type);
19441 result->value.data.x_err_set = err;
19442 return result;
1979419443 }
1979519444 }
1979619445
19797 ir_build_unwrap_err_code_from(&ira->new_irb, &instruction->base, value);
19798 return type_entry->data.error_union.err_set_type;
19446 IrInstruction *result = ir_build_unwrap_err_code(&ira->new_irb,
19447 instruction->base.scope, instruction->base.source_node, value);
19448 result->value.type = type_entry->data.error_union.err_set_type;
19449 return result;
1979919450 } else {
1980019451 ir_add_error(ira, value,
1980119452 buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
19802 return ira->codegen->builtin_types.entry_invalid;
19453 return ira->codegen->invalid_instruction;
1980319454 }
1980419455}
1980519456
19806static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
19457static IrInstruction *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
1980719458 IrInstructionUnwrapErrPayload *instruction)
1980819459{
19809 assert(instruction->value->other);
19810 IrInstruction *value = instruction->value->other;
19460 assert(instruction->value->child);
19461 IrInstruction *value = instruction->value->child;
1981119462 if (type_is_invalid(value->value.type))
19812 return ira->codegen->builtin_types.entry_invalid;
19463 return ira->codegen->invalid_instruction;
1981319464 ZigType *ptr_type = value->value.type;
1981419465
1981519466 // This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
......@@ -19817,11 +19468,11 @@ static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
1981719468
1981819469 ZigType *type_entry = ptr_type->data.pointer.child_type;
1981919470 if (type_is_invalid(type_entry)) {
19820 return ira->codegen->builtin_types.entry_invalid;
19471 return ira->codegen->invalid_instruction;
1982119472 } else if (type_entry->id == ZigTypeIdErrorUnion) {
1982219473 ZigType *payload_type = type_entry->data.error_union.payload_type;
1982319474 if (type_is_invalid(payload_type)) {
19824 return ira->codegen->builtin_types.entry_invalid;
19475 return ira->codegen->invalid_instruction;
1982519476 }
1982619477 ZigType *result_type = get_pointer_to_type_extra(ira->codegen, payload_type,
1982719478 ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
......@@ -19829,36 +19480,38 @@ static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
1982919480 if (instr_is_comptime(value)) {
1983019481 ConstExprValue *ptr_val = ir_resolve_const(ira, value, UndefBad);
1983119482 if (!ptr_val)
19832 return ira->codegen->builtin_types.entry_invalid;
19483 return ira->codegen->invalid_instruction;
1983319484 ConstExprValue *err_union_val = ir_const_ptr_pointee(ira, ptr_val, instruction->base.source_node);
1983419485 if (err_union_val == nullptr)
19835 return ira->codegen->builtin_types.entry_invalid;
19486 return ira->codegen->invalid_instruction;
1983619487 if (err_union_val->special != ConstValSpecialRuntime) {
1983719488 ErrorTableEntry *err = err_union_val->data.x_err_union.err;
1983819489 if (err != nullptr) {
1983919490 ir_add_error(ira, &instruction->base,
1984019491 buf_sprintf("caught unexpected error '%s'", buf_ptr(&err->name)));
19841 return ira->codegen->builtin_types.entry_invalid;
19492 return ira->codegen->invalid_instruction;
1984219493 }
1984319494
19844 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19845 out_val->data.x_ptr.special = ConstPtrSpecialRef;
19846 out_val->data.x_ptr.data.ref.pointee = err_union_val->data.x_err_union.payload;
19847 return result_type;
19495 IrInstruction *result = ir_const(ira, &instruction->base, result_type);
19496 result->value.data.x_ptr.special = ConstPtrSpecialRef;
19497 result->value.data.x_ptr.data.ref.pointee = err_union_val->data.x_err_union.payload;
19498 return result;
1984819499 }
1984919500 }
1985019501
19851 ir_build_unwrap_err_payload_from(&ira->new_irb, &instruction->base, value, instruction->safety_check_on);
19852 return result_type;
19502 IrInstruction *result = ir_build_unwrap_err_payload(&ira->new_irb,
19503 instruction->base.scope, instruction->base.source_node, value, instruction->safety_check_on);
19504 result->value.type = result_type;
19505 return result;
1985319506 } else {
1985419507 ir_add_error(ira, value,
1985519508 buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
19856 return ira->codegen->builtin_types.entry_invalid;
19509 return ira->codegen->invalid_instruction;
1985719510 }
1985819511
1985919512}
1986019513
19861static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnProto *instruction) {
19514static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnProto *instruction) {
1986219515 Error err;
1986319516 AstNode *proto_node = instruction->base.source_node;
1986419517 assert(proto_node->type == NodeTypeFnProto);
......@@ -19866,7 +19519,7 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
1986619519 if (proto_node->data.fn_proto.auto_err_set) {
1986719520 ir_add_error(ira, &instruction->base,
1986819521 buf_sprintf("inferring error set of return type valid only for function definitions"));
19869 return ira->codegen->builtin_types.entry_invalid;
19522 return ira->codegen->invalid_instruction;
1987019523 }
1987119524
1987219525 FnTypeId fn_type_id = {0};
......@@ -19882,9 +19535,7 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
1988219535 fn_type_id.param_count = fn_type_id.next_param_index;
1988319536 continue;
1988419537 } else if (fn_type_id.cc == CallingConventionUnspecified) {
19885 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19886 out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
19887 return ira->codegen->builtin_types.entry_type;
19538 return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
1988819539 } else {
1988919540 zig_unreachable();
1989019541 }
......@@ -19894,36 +19545,32 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
1989419545
1989519546 if (instruction->param_types[fn_type_id.next_param_index] == nullptr) {
1989619547 param_info->type = nullptr;
19897 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19898 out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
19899 return ira->codegen->builtin_types.entry_type;
19548 return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
1990019549 } else {
19901 IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->other;
19550 IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->child;
1990219551 if (type_is_invalid(param_type_value->value.type))
19903 return ira->codegen->builtin_types.entry_invalid;
19552 return ira->codegen->invalid_instruction;
1990419553 ZigType *param_type = ir_resolve_type(ira, param_type_value);
1990519554 if (type_is_invalid(param_type))
19906 return ira->codegen->builtin_types.entry_invalid;
19555 return ira->codegen->invalid_instruction;
1990719556 if ((err = type_resolve(ira->codegen, param_type, ResolveStatusZeroBitsKnown)))
19908 return ira->codegen->builtin_types.entry_invalid;
19557 return ira->codegen->invalid_instruction;
1990919558 if (type_requires_comptime(param_type)) {
1991019559 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
1991119560 ir_add_error(ira, param_type_value,
1991219561 buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'",
1991319562 buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
19914 return ira->codegen->builtin_types.entry_invalid;
19563 return ira->codegen->invalid_instruction;
1991519564 }
1991619565 param_info->type = param_type;
1991719566 fn_type_id.next_param_index += 1;
19918 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19919 out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
19920 return ira->codegen->builtin_types.entry_type;
19567 return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
1992119568 }
1992219569 if (!type_has_bits(param_type) && !calling_convention_allows_zig_types(fn_type_id.cc)) {
1992319570 ir_add_error(ira, param_type_value,
1992419571 buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
1992519572 buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
19926 return ira->codegen->builtin_types.entry_invalid;
19573 return ira->codegen->invalid_instruction;
1992719574 }
1992819575 param_info->type = param_type;
1992919576 }
......@@ -19931,54 +19578,50 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
1993119578 }
1993219579
1993319580 if (instruction->align_value != nullptr) {
19934 if (!ir_resolve_align(ira, instruction->align_value->other, &fn_type_id.alignment))
19935 return ira->codegen->builtin_types.entry_invalid;
19581 if (!ir_resolve_align(ira, instruction->align_value->child, &fn_type_id.alignment))
19582 return ira->codegen->invalid_instruction;
1993619583 }
1993719584
19938 IrInstruction *return_type_value = instruction->return_type->other;
19585 IrInstruction *return_type_value = instruction->return_type->child;
1993919586 fn_type_id.return_type = ir_resolve_type(ira, return_type_value);
1994019587 if (type_is_invalid(fn_type_id.return_type))
19941 return ira->codegen->builtin_types.entry_invalid;
19588 return ira->codegen->invalid_instruction;
1994219589 if (fn_type_id.return_type->id == ZigTypeIdOpaque) {
1994319590 ir_add_error(ira, instruction->return_type,
1994419591 buf_sprintf("return type cannot be opaque"));
19945 return ira->codegen->builtin_types.entry_invalid;
19592 return ira->codegen->invalid_instruction;
1994619593 }
1994719594
1994819595 if (fn_type_id.cc == CallingConventionAsync) {
1994919596 if (instruction->async_allocator_type_value == nullptr) {
1995019597 ir_add_error(ira, &instruction->base,
1995119598 buf_sprintf("async fn proto missing allocator type"));
19952 return ira->codegen->builtin_types.entry_invalid;
19599 return ira->codegen->invalid_instruction;
1995319600 }
19954 IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->other;
19601 IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->child;
1995519602 fn_type_id.async_allocator_type = ir_resolve_type(ira, async_allocator_type_value);
1995619603 if (type_is_invalid(fn_type_id.async_allocator_type))
19957 return ira->codegen->builtin_types.entry_invalid;
19604 return ira->codegen->invalid_instruction;
1995819605 }
1995919606
19960 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19961 out_val->data.x_type = get_fn_type(ira->codegen, &fn_type_id);
19962 return ira->codegen->builtin_types.entry_type;
19607 return ir_const_type(ira, &instruction->base, get_fn_type(ira->codegen, &fn_type_id));
1996319608}
1996419609
19965static ZigType *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) {
19966 IrInstruction *value = instruction->value->other;
19610static IrInstruction *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) {
19611 IrInstruction *value = instruction->value->child;
1996719612 if (type_is_invalid(value->value.type))
19968 return ira->codegen->builtin_types.entry_invalid;
19613 return ira->codegen->invalid_instruction;
1996919614
19970 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
19971 out_val->data.x_bool = instr_is_comptime(value);
19972 return ira->codegen->builtin_types.entry_bool;
19615 return ir_const_bool(ira, &instruction->base, instr_is_comptime(value));
1997319616}
1997419617
19975static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
19618static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
1997619619 IrInstructionCheckSwitchProngs *instruction)
1997719620{
19978 IrInstruction *target_value = instruction->target_value->other;
19621 IrInstruction *target_value = instruction->target_value->child;
1997919622 ZigType *switch_type = target_value->value.type;
1998019623 if (type_is_invalid(switch_type))
19981 return ira->codegen->builtin_types.entry_invalid;
19624 return ira->codegen->invalid_instruction;
1998219625
1998319626 if (switch_type->id == ZigTypeIdEnum) {
1998419627 HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> field_prev_uses = {};
......@@ -19987,17 +19630,17 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
1998719630 for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
1998819631 IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
1998919632
19990 IrInstruction *start_value = range->start->other;
19633 IrInstruction *start_value = range->start->child;
1999119634 if (type_is_invalid(start_value->value.type))
19992 return ira->codegen->builtin_types.entry_invalid;
19635 return ira->codegen->invalid_instruction;
1999319636
19994 IrInstruction *end_value = range->end->other;
19637 IrInstruction *end_value = range->end->child;
1999519638 if (type_is_invalid(end_value->value.type))
19996 return ira->codegen->builtin_types.entry_invalid;
19639 return ira->codegen->invalid_instruction;
1999719640
1999819641 if (start_value->value.type->id != ZigTypeIdEnum) {
1999919642 ir_add_error(ira, range->start, buf_sprintf("not an enum type"));
20000 return ira->codegen->builtin_types.entry_invalid;
19643 return ira->codegen->invalid_instruction;
2000119644 }
2000219645
2000319646 BigInt start_index;
......@@ -20041,7 +19684,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2004119684 }
2004219685 } else if (switch_type->id == ZigTypeIdErrorSet) {
2004319686 if (!resolve_inferred_error_set(ira->codegen, switch_type, target_value->source_node)) {
20044 return ira->codegen->builtin_types.entry_invalid;
19687 return ira->codegen->invalid_instruction;
2004519688 }
2004619689
2004719690 AstNode **field_prev_uses = allocate<AstNode *>(ira->codegen->errors_by_index.length);
......@@ -20049,13 +19692,13 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2004919692 for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
2005019693 IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
2005119694
20052 IrInstruction *start_value = range->start->other;
19695 IrInstruction *start_value = range->start->child;
2005319696 if (type_is_invalid(start_value->value.type))
20054 return ira->codegen->builtin_types.entry_invalid;
19697 return ira->codegen->invalid_instruction;
2005519698
20056 IrInstruction *end_value = range->end->other;
19699 IrInstruction *end_value = range->end->child;
2005719700 if (type_is_invalid(end_value->value.type))
20058 return ira->codegen->builtin_types.entry_invalid;
19701 return ira->codegen->invalid_instruction;
2005919702
2006019703 assert(start_value->value.type->id == ZigTypeIdErrorSet);
2006119704 uint32_t start_index = start_value->value.data.x_err_set->value;
......@@ -20065,7 +19708,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2006519708
2006619709 if (start_index != end_index) {
2006719710 ir_add_error(ira, end_value, buf_sprintf("ranges not allowed when switching on errors"));
20068 return ira->codegen->builtin_types.entry_invalid;
19711 return ira->codegen->invalid_instruction;
2006919712 }
2007019713
2007119714 AstNode *prev_node = field_prev_uses[start_index];
......@@ -20081,7 +19724,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2008119724 if (type_is_global_error_set(switch_type)) {
2008219725 ir_add_error(ira, &instruction->base,
2008319726 buf_sprintf("else prong required when switching on type 'error'"));
20084 return ira->codegen->builtin_types.entry_invalid;
19727 return ira->codegen->invalid_instruction;
2008519728 } else {
2008619729 for (uint32_t i = 0; i < switch_type->data.error_set.err_count; i += 1) {
2008719730 ErrorTableEntry *err_entry = switch_type->data.error_set.errors[i];
......@@ -20101,27 +19744,27 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2010119744 for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
2010219745 IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
2010319746
20104 IrInstruction *start_value = range->start->other;
19747 IrInstruction *start_value = range->start->child;
2010519748 if (type_is_invalid(start_value->value.type))
20106 return ira->codegen->builtin_types.entry_invalid;
19749 return ira->codegen->invalid_instruction;
2010719750 IrInstruction *casted_start_value = ir_implicit_cast(ira, start_value, switch_type);
2010819751 if (type_is_invalid(casted_start_value->value.type))
20109 return ira->codegen->builtin_types.entry_invalid;
19752 return ira->codegen->invalid_instruction;
2011019753
20111 IrInstruction *end_value = range->end->other;
19754 IrInstruction *end_value = range->end->child;
2011219755 if (type_is_invalid(end_value->value.type))
20113 return ira->codegen->builtin_types.entry_invalid;
19756 return ira->codegen->invalid_instruction;
2011419757 IrInstruction *casted_end_value = ir_implicit_cast(ira, end_value, switch_type);
2011519758 if (type_is_invalid(casted_end_value->value.type))
20116 return ira->codegen->builtin_types.entry_invalid;
19759 return ira->codegen->invalid_instruction;
2011719760
2011819761 ConstExprValue *start_val = ir_resolve_const(ira, casted_start_value, UndefBad);
2011919762 if (!start_val)
20120 return ira->codegen->builtin_types.entry_invalid;
19763 return ira->codegen->invalid_instruction;
2012119764
2012219765 ConstExprValue *end_val = ir_resolve_const(ira, casted_end_value, UndefBad);
2012319766 if (!end_val)
20124 return ira->codegen->builtin_types.entry_invalid;
19767 return ira->codegen->invalid_instruction;
2012519768
2012619769 assert(start_val->type->id == ZigTypeIdInt || start_val->type->id == ZigTypeIdComptimeInt);
2012719770 assert(end_val->type->id == ZigTypeIdInt || end_val->type->id == ZigTypeIdComptimeInt);
......@@ -20130,7 +19773,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2013019773 if (prev_node != nullptr) {
2013119774 ErrorMsg *msg = ir_add_error(ira, start_value, buf_sprintf("duplicate switch value"));
2013219775 add_error_note(ira->codegen, msg, prev_node, buf_sprintf("previous value is here"));
20133 return ira->codegen->builtin_types.entry_invalid;
19776 return ira->codegen->invalid_instruction;
2013419777 }
2013519778 }
2013619779 if (!instruction->have_else_prong) {
......@@ -20140,36 +19783,34 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2014019783 eval_min_max_value_int(ira->codegen, switch_type, &max_val, true);
2014119784 if (!rangeset_spans(&rs, &min_val, &max_val)) {
2014219785 ir_add_error(ira, &instruction->base, buf_sprintf("switch must handle all possibilities"));
20143 return ira->codegen->builtin_types.entry_invalid;
19786 return ira->codegen->invalid_instruction;
2014419787 }
2014519788 }
2014619789 } else if (!instruction->have_else_prong) {
2014719790 ir_add_error(ira, &instruction->base,
2014819791 buf_sprintf("else prong required when switching on type '%s'", buf_ptr(&switch_type->name)));
20149 return ira->codegen->builtin_types.entry_invalid;
19792 return ira->codegen->invalid_instruction;
2015019793 }
20151 ir_build_const_from(ira, &instruction->base);
20152 return ira->codegen->builtin_types.entry_void;
19794 return ir_const_void(ira, &instruction->base);
2015319795}
2015419796
20155static ZigType *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira,
19797static IrInstruction *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira,
2015619798 IrInstructionCheckStatementIsVoid *instruction)
2015719799{
20158 IrInstruction *statement_value = instruction->statement_value->other;
19800 IrInstruction *statement_value = instruction->statement_value->child;
2015919801 ZigType *statement_type = statement_value->value.type;
2016019802 if (type_is_invalid(statement_type))
20161 return ira->codegen->builtin_types.entry_invalid;
19803 return ira->codegen->invalid_instruction;
2016219804
2016319805 if (statement_type->id != ZigTypeIdVoid) {
2016419806 ir_add_error(ira, &instruction->base, buf_sprintf("expression value is ignored"));
2016519807 }
2016619808
20167 ir_build_const_from(ira, &instruction->base);
20168 return ira->codegen->builtin_types.entry_void;
19809 return ir_const_void(ira, &instruction->base);
2016919810}
2017019811
20171static ZigType *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic *instruction) {
20172 IrInstruction *msg = instruction->msg->other;
19812static IrInstruction *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic *instruction) {
19813 IrInstruction *msg = instruction->msg->child;
2017319814 if (type_is_invalid(msg->value.type))
2017419815 return ir_unreach_error(ira);
2017519816
......@@ -20187,8 +19828,7 @@ static ZigType *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic
2018719828
2018819829 IrInstruction *new_instruction = ir_build_panic(&ira->new_irb, instruction->base.scope,
2018919830 instruction->base.source_node, casted_msg);
20190 ir_link_new_instruction(new_instruction, &instruction->base);
20191 return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
19831 return ir_finish_anal(ira, new_instruction);
2019219832}
2019319833
2019419834static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint32_t align_bytes, bool safety_check_on) {
......@@ -20352,23 +19992,18 @@ static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_
2035219992 return result;
2035319993}
2035419994
20355static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
20356 IrInstruction *dest_type_value = instruction->dest_type->other;
19995static IrInstruction *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
19996 IrInstruction *dest_type_value = instruction->dest_type->child;
2035719997 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
2035819998 if (type_is_invalid(dest_type))
20359 return ira->codegen->builtin_types.entry_invalid;
19999 return ira->codegen->invalid_instruction;
2036020000
20361 IrInstruction *ptr = instruction->ptr->other;
20001 IrInstruction *ptr = instruction->ptr->child;
2036220002 ZigType *src_type = ptr->value.type;
2036320003 if (type_is_invalid(src_type))
20364 return ira->codegen->builtin_types.entry_invalid;
20365
20366 IrInstruction *result = ir_analyze_ptr_cast(ira, &instruction->base, ptr, dest_type, dest_type_value);
20367 if (type_is_invalid(result->value.type))
20368 return ira->codegen->builtin_types.entry_invalid;
20004 return ira->codegen->invalid_instruction;
2036920005
20370 ir_link_new_instruction(result, &instruction->base);
20371 return result->value.type;
20006 return ir_analyze_ptr_cast(ira, &instruction->base, ptr, dest_type, dest_type_value);
2037220007}
2037320008
2037420009static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val) {
......@@ -20498,28 +20133,28 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
2049820133 zig_unreachable();
2049920134}
2050020135
20501static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
20136static IrInstruction *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
2050220137 Error err;
20503 IrInstruction *dest_type_value = instruction->dest_type->other;
20138 IrInstruction *dest_type_value = instruction->dest_type->child;
2050420139 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
2050520140 if (type_is_invalid(dest_type))
20506 return ira->codegen->builtin_types.entry_invalid;
20141 return ira->codegen->invalid_instruction;
2050720142
20508 IrInstruction *value = instruction->value->other;
20143 IrInstruction *value = instruction->value->child;
2050920144 ZigType *src_type = value->value.type;
2051020145 if (type_is_invalid(src_type))
20511 return ira->codegen->builtin_types.entry_invalid;
20146 return ira->codegen->invalid_instruction;
2051220147
2051320148 if ((err = ensure_complete_type(ira->codegen, dest_type)))
20514 return ira->codegen->builtin_types.entry_invalid;
20149 return ira->codegen->invalid_instruction;
2051520150
2051620151 if ((err = ensure_complete_type(ira->codegen, src_type)))
20517 return ira->codegen->builtin_types.entry_invalid;
20152 return ira->codegen->invalid_instruction;
2051820153
2051920154 if (get_codegen_ptr_type(src_type) != nullptr) {
2052020155 ir_add_error(ira, value,
2052120156 buf_sprintf("unable to @bitCast from pointer type '%s'", buf_ptr(&src_type->name)));
20522 return ira->codegen->builtin_types.entry_invalid;
20157 return ira->codegen->invalid_instruction;
2052320158 }
2052420159
2052520160 switch (src_type->id) {
......@@ -20536,7 +20171,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
2053620171 case ZigTypeIdNull:
2053720172 ir_add_error(ira, dest_type_value,
2053820173 buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&src_type->name)));
20539 return ira->codegen->builtin_types.entry_invalid;
20174 return ira->codegen->invalid_instruction;
2054020175 default:
2054120176 break;
2054220177 }
......@@ -20544,7 +20179,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
2054420179 if (get_codegen_ptr_type(dest_type) != nullptr) {
2054520180 ir_add_error(ira, dest_type_value,
2054620181 buf_sprintf("unable to @bitCast to pointer type '%s'", buf_ptr(&dest_type->name)));
20547 return ira->codegen->builtin_types.entry_invalid;
20182 return ira->codegen->invalid_instruction;
2054820183 }
2054920184
2055020185 switch (dest_type->id) {
......@@ -20561,7 +20196,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
2056120196 case ZigTypeIdNull:
2056220197 ir_add_error(ira, dest_type_value,
2056320198 buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
20564 return ira->codegen->builtin_types.entry_invalid;
20199 return ira->codegen->invalid_instruction;
2056520200 default:
2056620201 break;
2056720202 }
......@@ -20573,76 +20208,74 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
2057320208 buf_sprintf("destination type '%s' has size %" ZIG_PRI_u64 " but source type '%s' has size %" ZIG_PRI_u64,
2057420209 buf_ptr(&dest_type->name), dest_size_bytes,
2057520210 buf_ptr(&src_type->name), src_size_bytes));
20576 return ira->codegen->builtin_types.entry_invalid;
20211 return ira->codegen->invalid_instruction;
2057720212 }
2057820213
2057920214 if (instr_is_comptime(value)) {
2058020215 ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
2058120216 if (!val)
20582 return ira->codegen->builtin_types.entry_invalid;
20217 return ira->codegen->invalid_instruction;
2058320218
20584 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20585 out_val->type = dest_type;
20219 IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
2058620220 uint8_t *buf = allocate_nonzero<uint8_t>(src_size_bytes);
2058720221 buf_write_value_bytes(ira->codegen, buf, val);
20588 buf_read_value_bytes(ira->codegen, buf, out_val);
20589 return dest_type;
20222 buf_read_value_bytes(ira->codegen, buf, &result->value);
20223 return result;
2059020224 }
2059120225
2059220226 IrInstruction *result = ir_build_bit_cast(&ira->new_irb, instruction->base.scope,
2059320227 instruction->base.source_node, nullptr, value);
20594 ir_link_new_instruction(result, &instruction->base);
2059520228 result->value.type = dest_type;
20596 return dest_type;
20229 return result;
2059720230}
2059820231
20599static ZigType *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
20232static IrInstruction *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
2060020233 Error err;
20601 IrInstruction *dest_type_value = instruction->dest_type->other;
20234 IrInstruction *dest_type_value = instruction->dest_type->child;
2060220235 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
2060320236 if (type_is_invalid(dest_type))
20604 return ira->codegen->builtin_types.entry_invalid;
20237 return ira->codegen->invalid_instruction;
2060520238
2060620239 // We explicitly check for the size, so we can use get_src_ptr_type
2060720240 if (get_src_ptr_type(dest_type) == nullptr) {
2060820241 ir_add_error(ira, dest_type_value, buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
20609 return ira->codegen->builtin_types.entry_invalid;
20242 return ira->codegen->invalid_instruction;
2061020243 }
2061120244
2061220245 if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
20613 return ira->codegen->builtin_types.entry_invalid;
20246 return ira->codegen->invalid_instruction;
2061420247 if (!type_has_bits(dest_type)) {
2061520248 ir_add_error(ira, dest_type_value,
2061620249 buf_sprintf("type '%s' has 0 bits and cannot store information", buf_ptr(&dest_type->name)));
20617 return ira->codegen->builtin_types.entry_invalid;
20250 return ira->codegen->invalid_instruction;
2061820251 }
2061920252
20620 IrInstruction *target = instruction->target->other;
20253 IrInstruction *target = instruction->target->child;
2062120254 if (type_is_invalid(target->value.type))
20622 return ira->codegen->builtin_types.entry_invalid;
20255 return ira->codegen->invalid_instruction;
2062320256
2062420257 IrInstruction *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
2062520258 if (type_is_invalid(casted_int->value.type))
20626 return ira->codegen->builtin_types.entry_invalid;
20259 return ira->codegen->invalid_instruction;
2062720260
2062820261 if (instr_is_comptime(casted_int)) {
2062920262 ConstExprValue *val = ir_resolve_const(ira, casted_int, UndefBad);
2063020263 if (!val)
20631 return ira->codegen->builtin_types.entry_invalid;
20264 return ira->codegen->invalid_instruction;
2063220265
20633 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20634 out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
20635 out_val->data.x_ptr.data.hard_coded_addr.addr = bigint_as_unsigned(&val->data.x_bigint);
20636 return dest_type;
20266 IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
20267 result->value.data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
20268 result->value.data.x_ptr.data.hard_coded_addr.addr = bigint_as_unsigned(&val->data.x_bigint);
20269 return result;
2063720270 }
2063820271
2063920272 IrInstruction *result = ir_build_int_to_ptr(&ira->new_irb, instruction->base.scope,
2064020273 instruction->base.source_node, nullptr, casted_int);
20641 ir_link_new_instruction(result, &instruction->base);
20642 return dest_type;
20274 result->value.type = dest_type;
20275 return result;
2064320276}
2064420277
20645static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
20278static IrInstruction *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
2064620279 IrInstructionDeclRef *instruction)
2064720280{
2064820281 Tld *tld = instruction->tld;
......@@ -20650,7 +20283,7 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
2065020283
2065120284 resolve_top_level_decl(ira->codegen, tld, lval == LValPtr, instruction->base.source_node);
2065220285 if (tld->resolution == TldResolutionInvalid)
20653 return ira->codegen->builtin_types.entry_invalid;
20286 return ira->codegen->invalid_instruction;
2065420287
2065520288 switch (tld->id) {
2065620289 case TldIdContainer:
......@@ -20663,19 +20296,16 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
2066320296
2066420297 IrInstruction *var_ptr = ir_get_var_ptr(ira, &instruction->base, var);
2066520298 if (type_is_invalid(var_ptr->value.type))
20666 return ira->codegen->builtin_types.entry_invalid;
20299 return ira->codegen->invalid_instruction;
2066720300
2066820301 if (tld_var->extern_lib_name != nullptr) {
2066920302 add_link_lib_symbol(ira, tld_var->extern_lib_name, &var->name, instruction->base.source_node);
2067020303 }
2067120304
2067220305 if (lval == LValPtr) {
20673 ir_link_new_instruction(var_ptr, &instruction->base);
20674 return var_ptr->value.type;
20306 return var_ptr;
2067520307 } else {
20676 IrInstruction *loaded_instr = ir_get_deref(ira, &instruction->base, var_ptr);
20677 ir_link_new_instruction(loaded_instr, &instruction->base);
20678 return loaded_instr->value.type;
20308 return ir_get_deref(ira, &instruction->base, var_ptr);
2067920309 }
2068020310 }
2068120311 case TldIdFn:
......@@ -20691,22 +20321,19 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
2069120321 IrInstruction *ref_instruction = ir_create_const_fn(&ira->new_irb, instruction->base.scope,
2069220322 instruction->base.source_node, fn_entry);
2069320323 if (lval == LValPtr) {
20694 IrInstruction *ptr_instr = ir_get_ref(ira, &instruction->base, ref_instruction, true, false);
20695 ir_link_new_instruction(ptr_instr, &instruction->base);
20696 return ptr_instr->value.type;
20324 return ir_get_ref(ira, &instruction->base, ref_instruction, true, false);
2069720325 } else {
20698 ir_link_new_instruction(ref_instruction, &instruction->base);
20699 return ref_instruction->value.type;
20326 return ref_instruction;
2070020327 }
2070120328 }
2070220329 }
2070320330 zig_unreachable();
2070420331}
2070520332
20706static ZigType *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionPtrToInt *instruction) {
20707 IrInstruction *target = instruction->target->other;
20333static IrInstruction *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionPtrToInt *instruction) {
20334 IrInstruction *target = instruction->target->child;
2070820335 if (type_is_invalid(target->value.type))
20709 return ira->codegen->builtin_types.entry_invalid;
20336 return ira->codegen->invalid_instruction;
2071020337
2071120338 ZigType *usize = ira->codegen->builtin_types.entry_usize;
2071220339
......@@ -20714,151 +20341,144 @@ static ZigType *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionP
2071420341 if (get_src_ptr_type(target->value.type) == nullptr) {
2071520342 ir_add_error(ira, target,
2071620343 buf_sprintf("expected pointer, found '%s'", buf_ptr(&target->value.type->name)));
20717 return ira->codegen->builtin_types.entry_invalid;
20344 return ira->codegen->invalid_instruction;
2071820345 }
2071920346
2072020347 if (!type_has_bits(target->value.type)) {
2072120348 ir_add_error(ira, target,
2072220349 buf_sprintf("pointer to size 0 type has no address"));
20723 return ira->codegen->builtin_types.entry_invalid;
20350 return ira->codegen->invalid_instruction;
2072420351 }
2072520352
2072620353 if (instr_is_comptime(target)) {
2072720354 ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
2072820355 if (!val)
20729 return ira->codegen->builtin_types.entry_invalid;
20356 return ira->codegen->invalid_instruction;
2073020357 if (val->type->id == ZigTypeIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
2073120358 IrInstruction *result = ir_create_const(&ira->new_irb, instruction->base.scope,
2073220359 instruction->base.source_node, usize);
2073320360 bigint_init_unsigned(&result->value.data.x_bigint, val->data.x_ptr.data.hard_coded_addr.addr);
20734 ir_link_new_instruction(result, &instruction->base);
20735 return usize;
20361 result->value.type = usize;
20362 return result;
2073620363 }
2073720364 }
2073820365
2073920366 IrInstruction *result = ir_build_ptr_to_int(&ira->new_irb, instruction->base.scope,
2074020367 instruction->base.source_node, target);
2074120368 result->value.type = usize;
20742 ir_link_new_instruction(result, &instruction->base);
20743 return usize;
20369 return result;
2074420370}
2074520371
20746static ZigType *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
20372static IrInstruction *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
2074720373 Error err;
20748 ZigType *child_type = ir_resolve_type(ira, instruction->child_type->other);
20374 ZigType *child_type = ir_resolve_type(ira, instruction->child_type->child);
2074920375 if (type_is_invalid(child_type))
20750 return ira->codegen->builtin_types.entry_invalid;
20376 return ira->codegen->invalid_instruction;
2075120377
2075220378 if (child_type->id == ZigTypeIdUnreachable) {
2075320379 ir_add_error(ira, &instruction->base, buf_sprintf("pointer to noreturn not allowed"));
20754 return ira->codegen->builtin_types.entry_invalid;
20380 return ira->codegen->invalid_instruction;
2075520381 } else if (child_type->id == ZigTypeIdOpaque && instruction->ptr_len == PtrLenUnknown) {
2075620382 ir_add_error(ira, &instruction->base, buf_sprintf("unknown-length pointer to opaque"));
20757 return ira->codegen->builtin_types.entry_invalid;
20383 return ira->codegen->invalid_instruction;
2075820384 }
2075920385
2076020386 uint32_t align_bytes;
2076120387 if (instruction->align_value != nullptr) {
20762 if (!ir_resolve_align(ira, instruction->align_value->other, &align_bytes))
20763 return ira->codegen->builtin_types.entry_invalid;
20388 if (!ir_resolve_align(ira, instruction->align_value->child, &align_bytes))
20389 return ira->codegen->invalid_instruction;
2076420390 if ((err = type_resolve(ira->codegen, child_type, ResolveStatusAlignmentKnown)))
20765 return ira->codegen->builtin_types.entry_invalid;
20391 return ira->codegen->invalid_instruction;
2076620392 } else {
2076720393 if ((err = type_resolve(ira->codegen, child_type, ResolveStatusZeroBitsKnown)))
20768 return ira->codegen->builtin_types.entry_invalid;
20394 return ira->codegen->invalid_instruction;
2076920395 align_bytes = 0;
2077020396 }
2077120397
20772
20773 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20774 out_val->data.x_type = get_pointer_to_type_extra(ira->codegen, child_type,
20398 ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
2077520399 instruction->is_const, instruction->is_volatile,
2077620400 instruction->ptr_len, align_bytes,
2077720401 instruction->bit_offset_start, instruction->host_int_bytes);
20778
20779 return ira->codegen->builtin_types.entry_type;
20402 return ir_const_type(ira, &instruction->base, result_type);
2078020403}
2078120404
20782static ZigType *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstructionAlignCast *instruction) {
20405static IrInstruction *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstructionAlignCast *instruction) {
2078320406 uint32_t align_bytes;
20784 IrInstruction *align_bytes_inst = instruction->align_bytes->other;
20407 IrInstruction *align_bytes_inst = instruction->align_bytes->child;
2078520408 if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
20786 return ira->codegen->builtin_types.entry_invalid;
20409 return ira->codegen->invalid_instruction;
2078720410
20788 IrInstruction *target = instruction->target->other;
20411 IrInstruction *target = instruction->target->child;
2078920412 if (type_is_invalid(target->value.type))
20790 return ira->codegen->builtin_types.entry_invalid;
20413 return ira->codegen->invalid_instruction;
2079120414
2079220415 IrInstruction *result = ir_align_cast(ira, target, align_bytes, true);
2079320416 if (type_is_invalid(result->value.type))
20794 return ira->codegen->builtin_types.entry_invalid;
20417 return ira->codegen->invalid_instruction;
2079520418
20796 ir_link_new_instruction(result, &instruction->base);
20797 return result->value.type;
20419 return result;
2079820420}
2079920421
20800static ZigType *ir_analyze_instruction_opaque_type(IrAnalyze *ira, IrInstructionOpaqueType *instruction) {
20422static IrInstruction *ir_analyze_instruction_opaque_type(IrAnalyze *ira, IrInstructionOpaqueType *instruction) {
2080120423 Buf *name = get_anon_type_name(ira->codegen, ira->new_irb.exec, "opaque", instruction->base.source_node);
20802 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20803 out_val->data.x_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
20424 ZigType *result_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
2080420425 buf_ptr(name));
20805 return ira->codegen->builtin_types.entry_type;
20426 return ir_const_type(ira, &instruction->base, result_type);
2080620427}
2080720428
20808static ZigType *ir_analyze_instruction_set_align_stack(IrAnalyze *ira, IrInstructionSetAlignStack *instruction) {
20429static IrInstruction *ir_analyze_instruction_set_align_stack(IrAnalyze *ira, IrInstructionSetAlignStack *instruction) {
2080920430 uint32_t align_bytes;
20810 IrInstruction *align_bytes_inst = instruction->align_bytes->other;
20431 IrInstruction *align_bytes_inst = instruction->align_bytes->child;
2081120432 if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
20812 return ira->codegen->builtin_types.entry_invalid;
20433 return ira->codegen->invalid_instruction;
2081320434
2081420435 if (align_bytes > 256) {
2081520436 ir_add_error(ira, &instruction->base, buf_sprintf("attempt to @setAlignStack(%" PRIu32 "); maximum is 256", align_bytes));
20816 return ira->codegen->builtin_types.entry_invalid;
20437 return ira->codegen->invalid_instruction;
2081720438 }
2081820439
2081920440 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
2082020441 if (fn_entry == nullptr) {
2082120442 ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack outside function"));
20822 return ira->codegen->builtin_types.entry_invalid;
20443 return ira->codegen->invalid_instruction;
2082320444 }
2082420445 if (fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionNaked) {
2082520446 ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in naked function"));
20826 return ira->codegen->builtin_types.entry_invalid;
20447 return ira->codegen->invalid_instruction;
2082720448 }
2082820449
2082920450 if (fn_entry->fn_inline == FnInlineAlways) {
2083020451 ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in inline function"));
20831 return ira->codegen->builtin_types.entry_invalid;
20452 return ira->codegen->invalid_instruction;
2083220453 }
2083320454
2083420455 if (fn_entry->set_alignstack_node != nullptr) {
2083520456 ErrorMsg *msg = ir_add_error_node(ira, instruction->base.source_node,
2083620457 buf_sprintf("alignstack set twice"));
2083720458 add_error_note(ira->codegen, msg, fn_entry->set_alignstack_node, buf_sprintf("first set here"));
20838 return ira->codegen->builtin_types.entry_invalid;
20459 return ira->codegen->invalid_instruction;
2083920460 }
2084020461
2084120462 fn_entry->set_alignstack_node = instruction->base.source_node;
2084220463 fn_entry->alignstack_value = align_bytes;
2084320464
20844 ir_build_const_from(ira, &instruction->base);
20845 return ira->codegen->builtin_types.entry_void;
20465 return ir_const_void(ira, &instruction->base);
2084620466}
2084720467
20848static ZigType *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArgType *instruction) {
20849 IrInstruction *fn_type_inst = instruction->fn_type->other;
20468static IrInstruction *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArgType *instruction) {
20469 IrInstruction *fn_type_inst = instruction->fn_type->child;
2085020470 ZigType *fn_type = ir_resolve_type(ira, fn_type_inst);
2085120471 if (type_is_invalid(fn_type))
20852 return ira->codegen->builtin_types.entry_invalid;
20472 return ira->codegen->invalid_instruction;
2085320473
20854 IrInstruction *arg_index_inst = instruction->arg_index->other;
20474 IrInstruction *arg_index_inst = instruction->arg_index->child;
2085520475 uint64_t arg_index;
2085620476 if (!ir_resolve_usize(ira, arg_index_inst, &arg_index))
20857 return ira->codegen->builtin_types.entry_invalid;
20477 return ira->codegen->invalid_instruction;
2085820478
2085920479 if (fn_type->id != ZigTypeIdFn) {
2086020480 ir_add_error(ira, fn_type_inst, buf_sprintf("expected function, found '%s'", buf_ptr(&fn_type->name)));
20861 return ira->codegen->builtin_types.entry_invalid;
20481 return ira->codegen->invalid_instruction;
2086220482 }
2086320483
2086420484 FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
......@@ -20866,226 +20486,207 @@ static ZigType *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArg
2086620486 ir_add_error(ira, arg_index_inst,
2086720487 buf_sprintf("arg index %" ZIG_PRI_u64 " out of bounds; '%s' has %" ZIG_PRI_usize " arguments",
2086820488 arg_index, buf_ptr(&fn_type->name), fn_type_id->param_count));
20869 return ira->codegen->builtin_types.entry_invalid;
20489 return ira->codegen->invalid_instruction;
2087020490 }
2087120491
20872 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20873 out_val->data.x_type = fn_type_id->param_info[arg_index].type;
20874 if (out_val->data.x_type == nullptr) {
20492 ZigType *result_type = fn_type_id->param_info[arg_index].type;
20493 if (result_type == nullptr) {
2087520494 // Args are only unresolved if our function is generic.
2087620495 assert(fn_type->data.fn.is_generic);
2087720496
2087820497 ir_add_error(ira, arg_index_inst,
2087920498 buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
2088020499 arg_index, buf_ptr(&fn_type->name)));
20881 return ira->codegen->builtin_types.entry_invalid;
20500 return ira->codegen->invalid_instruction;
2088220501 }
20883
20884 return ira->codegen->builtin_types.entry_type;
20502 return ir_const_type(ira, &instruction->base, result_type);
2088520503}
2088620504
20887static ZigType *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
20505static IrInstruction *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
2088820506 Error err;
20889 IrInstruction *target_inst = instruction->target->other;
20507 IrInstruction *target_inst = instruction->target->child;
2089020508 ZigType *enum_type = ir_resolve_type(ira, target_inst);
2089120509 if (type_is_invalid(enum_type))
20892 return ira->codegen->builtin_types.entry_invalid;
20510 return ira->codegen->invalid_instruction;
2089320511
2089420512 if (enum_type->id == ZigTypeIdEnum) {
2089520513 if ((err = ensure_complete_type(ira->codegen, enum_type)))
20896 return ira->codegen->builtin_types.entry_invalid;
20514 return ira->codegen->invalid_instruction;
2089720515
20898 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20899 out_val->data.x_type = enum_type->data.enumeration.tag_int_type;
20900 return ira->codegen->builtin_types.entry_type;
20516 return ir_const_type(ira, &instruction->base, enum_type->data.enumeration.tag_int_type);
2090120517 } else if (enum_type->id == ZigTypeIdUnion) {
2090220518 if ((err = ensure_complete_type(ira->codegen, enum_type)))
20903 return ira->codegen->builtin_types.entry_invalid;
20519 return ira->codegen->invalid_instruction;
2090420520
2090520521 AstNode *decl_node = enum_type->data.unionation.decl_node;
2090620522 if (decl_node->data.container_decl.auto_enum || decl_node->data.container_decl.init_arg_expr != nullptr) {
2090720523 assert(enum_type->data.unionation.tag_type != nullptr);
2090820524
20909 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20910 out_val->data.x_type = enum_type->data.unionation.tag_type;
20911 return ira->codegen->builtin_types.entry_type;
20525 return ir_const_type(ira, &instruction->base, enum_type->data.unionation.tag_type);
2091220526 } else {
2091320527 ErrorMsg *msg = ir_add_error(ira, target_inst, buf_sprintf("union '%s' has no tag",
2091420528 buf_ptr(&enum_type->name)));
2091520529 add_error_note(ira->codegen, msg, decl_node, buf_sprintf("consider 'union(enum)' here"));
20916 return ira->codegen->builtin_types.entry_invalid;
20530 return ira->codegen->invalid_instruction;
2091720531 }
2091820532 } else {
2091920533 ir_add_error(ira, target_inst, buf_sprintf("expected enum or union, found '%s'",
2092020534 buf_ptr(&enum_type->name)));
20921 return ira->codegen->builtin_types.entry_invalid;
20535 return ira->codegen->invalid_instruction;
2092220536 }
2092320537}
2092420538
20925static ZigType *ir_analyze_instruction_cancel(IrAnalyze *ira, IrInstructionCancel *instruction) {
20926 IrInstruction *target_inst = instruction->target->other;
20539static IrInstruction *ir_analyze_instruction_cancel(IrAnalyze *ira, IrInstructionCancel *instruction) {
20540 IrInstruction *target_inst = instruction->target->child;
2092720541 if (type_is_invalid(target_inst->value.type))
20928 return ira->codegen->builtin_types.entry_invalid;
20542 return ira->codegen->invalid_instruction;
2092920543 IrInstruction *casted_target = ir_implicit_cast(ira, target_inst, ira->codegen->builtin_types.entry_promise);
2093020544 if (type_is_invalid(casted_target->value.type))
20931 return ira->codegen->builtin_types.entry_invalid;
20545 return ira->codegen->invalid_instruction;
2093220546
2093320547 IrInstruction *result = ir_build_cancel(&ira->new_irb, instruction->base.scope, instruction->base.source_node, casted_target);
2093420548 result->value.type = ira->codegen->builtin_types.entry_void;
2093520549 result->value.special = ConstValSpecialStatic;
20936 ir_link_new_instruction(result, &instruction->base);
20937 return result->value.type;
20550 return result;
2093820551}
2093920552
20940static ZigType *ir_analyze_instruction_coro_id(IrAnalyze *ira, IrInstructionCoroId *instruction) {
20941 IrInstruction *promise_ptr = instruction->promise_ptr->other;
20553static IrInstruction *ir_analyze_instruction_coro_id(IrAnalyze *ira, IrInstructionCoroId *instruction) {
20554 IrInstruction *promise_ptr = instruction->promise_ptr->child;
2094220555 if (type_is_invalid(promise_ptr->value.type))
20943 return ira->codegen->builtin_types.entry_invalid;
20556 return ira->codegen->invalid_instruction;
2094420557
2094520558 IrInstruction *result = ir_build_coro_id(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
2094620559 promise_ptr);
20947 ir_link_new_instruction(result, &instruction->base);
2094820560 result->value.type = ira->codegen->builtin_types.entry_usize;
20949 return result->value.type;
20561 return result;
2095020562}
2095120563
20952static ZigType *ir_analyze_instruction_coro_alloc(IrAnalyze *ira, IrInstructionCoroAlloc *instruction) {
20953 IrInstruction *coro_id = instruction->coro_id->other;
20564static IrInstruction *ir_analyze_instruction_coro_alloc(IrAnalyze *ira, IrInstructionCoroAlloc *instruction) {
20565 IrInstruction *coro_id = instruction->coro_id->child;
2095420566 if (type_is_invalid(coro_id->value.type))
20955 return ira->codegen->builtin_types.entry_invalid;
20567 return ira->codegen->invalid_instruction;
2095620568
2095720569 IrInstruction *result = ir_build_coro_alloc(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
2095820570 coro_id);
20959 ir_link_new_instruction(result, &instruction->base);
2096020571 result->value.type = ira->codegen->builtin_types.entry_bool;
20961 return result->value.type;
20572 return result;
2096220573}
2096320574
20964static ZigType *ir_analyze_instruction_coro_size(IrAnalyze *ira, IrInstructionCoroSize *instruction) {
20575static IrInstruction *ir_analyze_instruction_coro_size(IrAnalyze *ira, IrInstructionCoroSize *instruction) {
2096520576 IrInstruction *result = ir_build_coro_size(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
20966 ir_link_new_instruction(result, &instruction->base);
2096720577 result->value.type = ira->codegen->builtin_types.entry_usize;
20968 return result->value.type;
20578 return result;
2096920579}
2097020580
20971static ZigType *ir_analyze_instruction_coro_begin(IrAnalyze *ira, IrInstructionCoroBegin *instruction) {
20972 IrInstruction *coro_id = instruction->coro_id->other;
20581static IrInstruction *ir_analyze_instruction_coro_begin(IrAnalyze *ira, IrInstructionCoroBegin *instruction) {
20582 IrInstruction *coro_id = instruction->coro_id->child;
2097320583 if (type_is_invalid(coro_id->value.type))
20974 return ira->codegen->builtin_types.entry_invalid;
20584 return ira->codegen->invalid_instruction;
2097520585
20976 IrInstruction *coro_mem_ptr = instruction->coro_mem_ptr->other;
20586 IrInstruction *coro_mem_ptr = instruction->coro_mem_ptr->child;
2097720587 if (type_is_invalid(coro_mem_ptr->value.type))
20978 return ira->codegen->builtin_types.entry_invalid;
20588 return ira->codegen->invalid_instruction;
2097920589
2098020590 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
2098120591 assert(fn_entry != nullptr);
2098220592 IrInstruction *result = ir_build_coro_begin(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
2098320593 coro_id, coro_mem_ptr);
20984 ir_link_new_instruction(result, &instruction->base);
2098520594 result->value.type = get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
20986 return result->value.type;
20595 return result;
2098720596}
2098820597
20989static ZigType *ir_analyze_instruction_get_implicit_allocator(IrAnalyze *ira, IrInstructionGetImplicitAllocator *instruction) {
20990 IrInstruction *result = ir_get_implicit_allocator(ira, &instruction->base, instruction->id);
20991 ir_link_new_instruction(result, &instruction->base);
20992 return result->value.type;
20598static IrInstruction *ir_analyze_instruction_get_implicit_allocator(IrAnalyze *ira, IrInstructionGetImplicitAllocator *instruction) {
20599 return ir_get_implicit_allocator(ira, &instruction->base, instruction->id);
2099320600}
2099420601
20995static ZigType *ir_analyze_instruction_coro_alloc_fail(IrAnalyze *ira, IrInstructionCoroAllocFail *instruction) {
20996 IrInstruction *err_val = instruction->err_val->other;
20602static IrInstruction *ir_analyze_instruction_coro_alloc_fail(IrAnalyze *ira, IrInstructionCoroAllocFail *instruction) {
20603 IrInstruction *err_val = instruction->err_val->child;
2099720604 if (type_is_invalid(err_val->value.type))
2099820605 return ir_unreach_error(ira);
2099920606
2100020607 IrInstruction *result = ir_build_coro_alloc_fail(&ira->new_irb, instruction->base.scope, instruction->base.source_node, err_val);
21001 ir_link_new_instruction(result, &instruction->base);
2100220608 result->value.type = ira->codegen->builtin_types.entry_unreachable;
21003 return ir_finish_anal(ira, result->value.type);
20609 return ir_finish_anal(ira, result);
2100420610}
2100520611
21006static ZigType *ir_analyze_instruction_coro_suspend(IrAnalyze *ira, IrInstructionCoroSuspend *instruction) {
20612static IrInstruction *ir_analyze_instruction_coro_suspend(IrAnalyze *ira, IrInstructionCoroSuspend *instruction) {
2100720613 IrInstruction *save_point = nullptr;
2100820614 if (instruction->save_point != nullptr) {
21009 save_point = instruction->save_point->other;
20615 save_point = instruction->save_point->child;
2101020616 if (type_is_invalid(save_point->value.type))
21011 return ira->codegen->builtin_types.entry_invalid;
20617 return ira->codegen->invalid_instruction;
2101220618 }
2101320619
21014 IrInstruction *is_final = instruction->is_final->other;
20620 IrInstruction *is_final = instruction->is_final->child;
2101520621 if (type_is_invalid(is_final->value.type))
21016 return ira->codegen->builtin_types.entry_invalid;
20622 return ira->codegen->invalid_instruction;
2101720623
2101820624 IrInstruction *result = ir_build_coro_suspend(&ira->new_irb, instruction->base.scope,
2101920625 instruction->base.source_node, save_point, is_final);
21020 ir_link_new_instruction(result, &instruction->base);
2102120626 result->value.type = ira->codegen->builtin_types.entry_u8;
21022 return result->value.type;
20627 return result;
2102320628}
2102420629
21025static ZigType *ir_analyze_instruction_coro_end(IrAnalyze *ira, IrInstructionCoroEnd *instruction) {
20630static IrInstruction *ir_analyze_instruction_coro_end(IrAnalyze *ira, IrInstructionCoroEnd *instruction) {
2102620631 IrInstruction *result = ir_build_coro_end(&ira->new_irb, instruction->base.scope,
2102720632 instruction->base.source_node);
21028 ir_link_new_instruction(result, &instruction->base);
2102920633 result->value.type = ira->codegen->builtin_types.entry_void;
21030 return result->value.type;
20634 return result;
2103120635}
2103220636
21033static ZigType *ir_analyze_instruction_coro_free(IrAnalyze *ira, IrInstructionCoroFree *instruction) {
21034 IrInstruction *coro_id = instruction->coro_id->other;
20637static IrInstruction *ir_analyze_instruction_coro_free(IrAnalyze *ira, IrInstructionCoroFree *instruction) {
20638 IrInstruction *coro_id = instruction->coro_id->child;
2103520639 if (type_is_invalid(coro_id->value.type))
21036 return ira->codegen->builtin_types.entry_invalid;
20640 return ira->codegen->invalid_instruction;
2103720641
21038 IrInstruction *coro_handle = instruction->coro_handle->other;
20642 IrInstruction *coro_handle = instruction->coro_handle->child;
2103920643 if (type_is_invalid(coro_handle->value.type))
21040 return ira->codegen->builtin_types.entry_invalid;
20644 return ira->codegen->invalid_instruction;
2104120645
2104220646 IrInstruction *result = ir_build_coro_free(&ira->new_irb, instruction->base.scope,
2104320647 instruction->base.source_node, coro_id, coro_handle);
21044 ir_link_new_instruction(result, &instruction->base);
2104520648 ZigType *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
2104620649 result->value.type = get_optional_type(ira->codegen, ptr_type);
21047 return result->value.type;
20650 return result;
2104820651}
2104920652
21050static ZigType *ir_analyze_instruction_coro_resume(IrAnalyze *ira, IrInstructionCoroResume *instruction) {
21051 IrInstruction *awaiter_handle = instruction->awaiter_handle->other;
20653static IrInstruction *ir_analyze_instruction_coro_resume(IrAnalyze *ira, IrInstructionCoroResume *instruction) {
20654 IrInstruction *awaiter_handle = instruction->awaiter_handle->child;
2105220655 if (type_is_invalid(awaiter_handle->value.type))
21053 return ira->codegen->builtin_types.entry_invalid;
20656 return ira->codegen->invalid_instruction;
2105420657
2105520658 IrInstruction *casted_target = ir_implicit_cast(ira, awaiter_handle, ira->codegen->builtin_types.entry_promise);
2105620659 if (type_is_invalid(casted_target->value.type))
21057 return ira->codegen->builtin_types.entry_invalid;
20660 return ira->codegen->invalid_instruction;
2105820661
2105920662 IrInstruction *result = ir_build_coro_resume(&ira->new_irb, instruction->base.scope,
2106020663 instruction->base.source_node, casted_target);
21061 ir_link_new_instruction(result, &instruction->base);
2106220664 result->value.type = ira->codegen->builtin_types.entry_void;
21063 return result->value.type;
20665 return result;
2106420666}
2106520667
21066static ZigType *ir_analyze_instruction_coro_save(IrAnalyze *ira, IrInstructionCoroSave *instruction) {
21067 IrInstruction *coro_handle = instruction->coro_handle->other;
20668static IrInstruction *ir_analyze_instruction_coro_save(IrAnalyze *ira, IrInstructionCoroSave *instruction) {
20669 IrInstruction *coro_handle = instruction->coro_handle->child;
2106820670 if (type_is_invalid(coro_handle->value.type))
21069 return ira->codegen->builtin_types.entry_invalid;
20671 return ira->codegen->invalid_instruction;
2107020672
2107120673 IrInstruction *result = ir_build_coro_save(&ira->new_irb, instruction->base.scope,
2107220674 instruction->base.source_node, coro_handle);
21073 ir_link_new_instruction(result, &instruction->base);
2107420675 result->value.type = ira->codegen->builtin_types.entry_usize;
21075 return result->value.type;
20676 return result;
2107620677}
2107720678
21078static ZigType *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructionCoroPromise *instruction) {
21079 IrInstruction *coro_handle = instruction->coro_handle->other;
20679static IrInstruction *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructionCoroPromise *instruction) {
20680 IrInstruction *coro_handle = instruction->coro_handle->child;
2108020681 if (type_is_invalid(coro_handle->value.type))
21081 return ira->codegen->builtin_types.entry_invalid;
20682 return ira->codegen->invalid_instruction;
2108220683
2108320684 if (coro_handle->value.type->id != ZigTypeIdPromise ||
2108420685 coro_handle->value.type->data.promise.result_type == nullptr)
2108520686 {
2108620687 ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
2108720688 buf_ptr(&coro_handle->value.type->name)));
21088 return ira->codegen->builtin_types.entry_invalid;
20689 return ira->codegen->invalid_instruction;
2108920690 }
2109020691
2109120692 ZigType *coro_frame_type = get_promise_frame_type(ira->codegen,
......@@ -21093,26 +20694,24 @@ static ZigType *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructio
2109320694
2109420695 IrInstruction *result = ir_build_coro_promise(&ira->new_irb, instruction->base.scope,
2109520696 instruction->base.source_node, coro_handle);
21096 ir_link_new_instruction(result, &instruction->base);
2109720697 result->value.type = get_pointer_to_type(ira->codegen, coro_frame_type, false);
21098 return result->value.type;
20698 return result;
2109920699}
2110020700
21101static ZigType *ir_analyze_instruction_coro_alloc_helper(IrAnalyze *ira, IrInstructionCoroAllocHelper *instruction) {
21102 IrInstruction *alloc_fn = instruction->alloc_fn->other;
20701static IrInstruction *ir_analyze_instruction_coro_alloc_helper(IrAnalyze *ira, IrInstructionCoroAllocHelper *instruction) {
20702 IrInstruction *alloc_fn = instruction->alloc_fn->child;
2110320703 if (type_is_invalid(alloc_fn->value.type))
21104 return ira->codegen->builtin_types.entry_invalid;
20704 return ira->codegen->invalid_instruction;
2110520705
21106 IrInstruction *coro_size = instruction->coro_size->other;
20706 IrInstruction *coro_size = instruction->coro_size->child;
2110720707 if (type_is_invalid(coro_size->value.type))
21108 return ira->codegen->builtin_types.entry_invalid;
20708 return ira->codegen->invalid_instruction;
2110920709
2111020710 IrInstruction *result = ir_build_coro_alloc_helper(&ira->new_irb, instruction->base.scope,
2111120711 instruction->base.source_node, alloc_fn, coro_size);
21112 ir_link_new_instruction(result, &instruction->base);
2111320712 ZigType *u8_ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
2111420713 result->value.type = get_optional_type(ira->codegen, u8_ptr_type);
21115 return result->value.type;
20714 return result;
2111620715}
2111720716
2111820717static ZigType *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstruction *op) {
......@@ -21147,48 +20746,48 @@ static ZigType *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstruction *op
2114720746 return operand_type;
2114820747}
2114920748
21150static ZigType *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionAtomicRmw *instruction) {
21151 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
20749static IrInstruction *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionAtomicRmw *instruction) {
20750 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
2115220751 if (type_is_invalid(operand_type))
21153 return ira->codegen->builtin_types.entry_invalid;
20752 return ira->codegen->invalid_instruction;
2115420753
21155 IrInstruction *ptr_inst = instruction->ptr->other;
20754 IrInstruction *ptr_inst = instruction->ptr->child;
2115620755 if (type_is_invalid(ptr_inst->value.type))
21157 return ira->codegen->builtin_types.entry_invalid;
20756 return ira->codegen->invalid_instruction;
2115820757
2115920758 // TODO let this be volatile
2116020759 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
2116120760 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
2116220761 if (type_is_invalid(casted_ptr->value.type))
21163 return ira->codegen->builtin_types.entry_invalid;
20762 return ira->codegen->invalid_instruction;
2116420763
2116520764 AtomicRmwOp op;
2116620765 if (instruction->op == nullptr) {
2116720766 op = instruction->resolved_op;
2116820767 } else {
21169 if (!ir_resolve_atomic_rmw_op(ira, instruction->op->other, &op)) {
21170 return ira->codegen->builtin_types.entry_invalid;
20768 if (!ir_resolve_atomic_rmw_op(ira, instruction->op->child, &op)) {
20769 return ira->codegen->invalid_instruction;
2117120770 }
2117220771 }
2117320772
21174 IrInstruction *operand = instruction->operand->other;
20773 IrInstruction *operand = instruction->operand->child;
2117520774 if (type_is_invalid(operand->value.type))
21176 return ira->codegen->builtin_types.entry_invalid;
20775 return ira->codegen->invalid_instruction;
2117720776
2117820777 IrInstruction *casted_operand = ir_implicit_cast(ira, operand, operand_type);
2117920778 if (type_is_invalid(casted_operand->value.type))
21180 return ira->codegen->builtin_types.entry_invalid;
20779 return ira->codegen->invalid_instruction;
2118120780
2118220781 AtomicOrder ordering;
2118320782 if (instruction->ordering == nullptr) {
2118420783 ordering = instruction->resolved_ordering;
2118520784 } else {
21186 if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
21187 return ira->codegen->builtin_types.entry_invalid;
20785 if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
20786 return ira->codegen->invalid_instruction;
2118820787 if (ordering == AtomicOrderUnordered) {
2118920788 ir_add_error(ira, instruction->ordering,
2119020789 buf_sprintf("@atomicRmw atomic ordering must not be Unordered"));
21191 return ira->codegen->builtin_types.entry_invalid;
20790 return ira->codegen->invalid_instruction;
2119220791 }
2119320792 }
2119420793
......@@ -21200,74 +20799,69 @@ static ZigType *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionA
2120020799 IrInstruction *result = ir_build_atomic_rmw(&ira->new_irb, instruction->base.scope,
2120120800 instruction->base.source_node, nullptr, casted_ptr, nullptr, casted_operand, nullptr,
2120220801 op, ordering);
21203 ir_link_new_instruction(result, &instruction->base);
2120420802 result->value.type = operand_type;
21205 return result->value.type;
20803 return result;
2120620804}
2120720805
21208static ZigType *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstructionAtomicLoad *instruction) {
21209 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
20806static IrInstruction *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstructionAtomicLoad *instruction) {
20807 ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
2121020808 if (type_is_invalid(operand_type))
21211 return ira->codegen->builtin_types.entry_invalid;
20809 return ira->codegen->invalid_instruction;
2121220810
21213 IrInstruction *ptr_inst = instruction->ptr->other;
20811 IrInstruction *ptr_inst = instruction->ptr->child;
2121420812 if (type_is_invalid(ptr_inst->value.type))
21215 return ira->codegen->builtin_types.entry_invalid;
20813 return ira->codegen->invalid_instruction;
2121620814
2121720815 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
2121820816 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
2121920817 if (type_is_invalid(casted_ptr->value.type))
21220 return ira->codegen->builtin_types.entry_invalid;
20818 return ira->codegen->invalid_instruction;
2122120819
2122220820 AtomicOrder ordering;
2122320821 if (instruction->ordering == nullptr) {
2122420822 ordering = instruction->resolved_ordering;
2122520823 } else {
21226 if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
21227 return ira->codegen->builtin_types.entry_invalid;
20824 if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
20825 return ira->codegen->invalid_instruction;
2122820826 }
2122920827
2123020828 if (ordering == AtomicOrderRelease || ordering == AtomicOrderAcqRel) {
2123120829 assert(instruction->ordering != nullptr);
2123220830 ir_add_error(ira, instruction->ordering,
2123320831 buf_sprintf("@atomicLoad atomic ordering must not be Release or AcqRel"));
21234 return ira->codegen->builtin_types.entry_invalid;
20832 return ira->codegen->invalid_instruction;
2123520833 }
2123620834
2123720835 if (instr_is_comptime(casted_ptr)) {
2123820836 IrInstruction *result = ir_get_deref(ira, &instruction->base, casted_ptr);
21239 ir_link_new_instruction(result, &instruction->base);
2124020837 assert(result->value.type != nullptr);
21241 return result->value.type;
20838 return result;
2124220839 }
2124320840
2124420841 IrInstruction *result = ir_build_atomic_load(&ira->new_irb, instruction->base.scope,
2124520842 instruction->base.source_node, nullptr, casted_ptr, nullptr, ordering);
21246 ir_link_new_instruction(result, &instruction->base);
2124720843 result->value.type = operand_type;
21248 return result->value.type;
20844 return result;
2124920845}
2125020846
21251static ZigType *ir_analyze_instruction_promise_result_type(IrAnalyze *ira, IrInstructionPromiseResultType *instruction) {
21252 ZigType *promise_type = ir_resolve_type(ira, instruction->promise_type->other);
20847static IrInstruction *ir_analyze_instruction_promise_result_type(IrAnalyze *ira, IrInstructionPromiseResultType *instruction) {
20848 ZigType *promise_type = ir_resolve_type(ira, instruction->promise_type->child);
2125320849 if (type_is_invalid(promise_type))
21254 return ira->codegen->builtin_types.entry_invalid;
20850 return ira->codegen->invalid_instruction;
2125520851
2125620852 if (promise_type->id != ZigTypeIdPromise || promise_type->data.promise.result_type == nullptr) {
2125720853 ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
2125820854 buf_ptr(&promise_type->name)));
21259 return ira->codegen->builtin_types.entry_invalid;
20855 return ira->codegen->invalid_instruction;
2126020856 }
2126120857
21262 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
21263 out_val->data.x_type = promise_type->data.promise.result_type;
21264 return ira->codegen->builtin_types.entry_type;
20858 return ir_const_type(ira, &instruction->base, promise_type->data.promise.result_type);
2126520859}
2126620860
21267static ZigType *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstructionAwaitBookkeeping *instruction) {
21268 ZigType *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->other);
20861static IrInstruction *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstructionAwaitBookkeeping *instruction) {
20862 ZigType *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->child);
2126920863 if (type_is_invalid(promise_result_type))
21270 return ira->codegen->builtin_types.entry_invalid;
20864 return ira->codegen->invalid_instruction;
2127120865
2127220866 ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
2127320867 assert(fn_entry != nullptr);
......@@ -21276,17 +20870,15 @@ static ZigType *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstr
2127620870 fn_entry->calls_or_awaits_errorable_fn = true;
2127720871 }
2127820872
21279 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
21280 out_val->type = ira->codegen->builtin_types.entry_void;
21281 return out_val->type;
20873 return ir_const_void(ira, &instruction->base);
2128220874}
2128320875
21284static ZigType *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
20876static IrInstruction *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
2128520877 IrInstructionMergeErrRetTraces *instruction)
2128620878{
21287 IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->other;
20879 IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->child;
2128820880 if (type_is_invalid(coro_promise_ptr->value.type))
21289 return ira->codegen->builtin_types.entry_invalid;
20881 return ira->codegen->invalid_instruction;
2129020882
2129120883 assert(coro_promise_ptr->value.type->id == ZigTypeIdPointer);
2129220884 ZigType *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
......@@ -21294,71 +20886,67 @@ static ZigType *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
2129420886 ZigType *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
2129520887
2129620888 if (!type_can_fail(promise_result_type)) {
21297 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
21298 out_val->type = ira->codegen->builtin_types.entry_void;
21299 return out_val->type;
20889 return ir_const_void(ira, &instruction->base);
2130020890 }
2130120891
21302 IrInstruction *src_err_ret_trace_ptr = instruction->src_err_ret_trace_ptr->other;
20892 IrInstruction *src_err_ret_trace_ptr = instruction->src_err_ret_trace_ptr->child;
2130320893 if (type_is_invalid(src_err_ret_trace_ptr->value.type))
21304 return ira->codegen->builtin_types.entry_invalid;
20894 return ira->codegen->invalid_instruction;
2130520895
21306 IrInstruction *dest_err_ret_trace_ptr = instruction->dest_err_ret_trace_ptr->other;
20896 IrInstruction *dest_err_ret_trace_ptr = instruction->dest_err_ret_trace_ptr->child;
2130720897 if (type_is_invalid(dest_err_ret_trace_ptr->value.type))
21308 return ira->codegen->builtin_types.entry_invalid;
20898 return ira->codegen->invalid_instruction;
2130920899
2131020900 IrInstruction *result = ir_build_merge_err_ret_traces(&ira->new_irb, instruction->base.scope,
2131120901 instruction->base.source_node, coro_promise_ptr, src_err_ret_trace_ptr, dest_err_ret_trace_ptr);
21312 ir_link_new_instruction(result, &instruction->base);
2131320902 result->value.type = ira->codegen->builtin_types.entry_void;
21314 return result->value.type;
20903 return result;
2131520904}
2131620905
21317static ZigType *ir_analyze_instruction_save_err_ret_addr(IrAnalyze *ira, IrInstructionSaveErrRetAddr *instruction) {
20906static IrInstruction *ir_analyze_instruction_save_err_ret_addr(IrAnalyze *ira, IrInstructionSaveErrRetAddr *instruction) {
2131820907 IrInstruction *result = ir_build_save_err_ret_addr(&ira->new_irb, instruction->base.scope,
2131920908 instruction->base.source_node);
21320 ir_link_new_instruction(result, &instruction->base);
2132120909 result->value.type = ira->codegen->builtin_types.entry_void;
21322 return result->value.type;
20910 return result;
2132320911}
2132420912
21325static ZigType *ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze *ira, IrInstructionMarkErrRetTracePtr *instruction) {
21326 IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->other;
20913static IrInstruction *ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze *ira, IrInstructionMarkErrRetTracePtr *instruction) {
20914 IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->child;
2132720915 if (type_is_invalid(err_ret_trace_ptr->value.type))
21328 return ira->codegen->builtin_types.entry_invalid;
20916 return ira->codegen->invalid_instruction;
2132920917
2133020918 IrInstruction *result = ir_build_mark_err_ret_trace_ptr(&ira->new_irb, instruction->base.scope,
2133120919 instruction->base.source_node, err_ret_trace_ptr);
21332 ir_link_new_instruction(result, &instruction->base);
2133320920 result->value.type = ira->codegen->builtin_types.entry_void;
21334 return result->value.type;
20921 return result;
2133520922}
2133620923
21337static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *instruction) {
21338 ZigType *float_type = ir_resolve_type(ira, instruction->type->other);
20924static IrInstruction *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *instruction) {
20925 ZigType *float_type = ir_resolve_type(ira, instruction->type->child);
2133920926 if (type_is_invalid(float_type))
21340 return ira->codegen->builtin_types.entry_invalid;
20927 return ira->codegen->invalid_instruction;
2134120928
21342 IrInstruction *op = instruction->op->other;
20929 IrInstruction *op = instruction->op->child;
2134320930 if (type_is_invalid(op->value.type))
21344 return ira->codegen->builtin_types.entry_invalid;
20931 return ira->codegen->invalid_instruction;
2134520932
2134620933 bool ok_type = float_type->id == ZigTypeIdComptimeFloat || float_type->id == ZigTypeIdFloat;
2134720934 if (!ok_type) {
2134820935 ir_add_error(ira, instruction->type, buf_sprintf("@sqrt does not support type '%s'", buf_ptr(&float_type->name)));
21349 return ira->codegen->builtin_types.entry_invalid;
20936 return ira->codegen->invalid_instruction;
2135020937 }
2135120938
2135220939 IrInstruction *casted_op = ir_implicit_cast(ira, op, float_type);
2135320940 if (type_is_invalid(casted_op->value.type))
21354 return ira->codegen->builtin_types.entry_invalid;
20941 return ira->codegen->invalid_instruction;
2135520942
2135620943 if (instr_is_comptime(casted_op)) {
2135720944 ConstExprValue *val = ir_resolve_const(ira, casted_op, UndefBad);
2135820945 if (!val)
21359 return ira->codegen->builtin_types.entry_invalid;
20946 return ira->codegen->invalid_instruction;
2136020947
21361 ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
20948 IrInstruction *result = ir_const(ira, &instruction->base, float_type);
20949 ConstExprValue *out_val = &result->value;
2136220950
2136320951 if (float_type->id == ZigTypeIdComptimeFloat) {
2136420952 bigfloat_sqrt(&out_val->data.x_bigfloat, &val->data.x_bigfloat);
......@@ -21383,7 +20971,7 @@ static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *i
2138320971 zig_unreachable();
2138420972 }
2138520973
21386 return float_type;
20974 return result;
2138720975 }
2138820976
2138920977 assert(float_type->id == ZigTypeIdFloat);
......@@ -21391,93 +20979,87 @@ static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *i
2139120979 float_type->data.floating.bit_count != 32 &&
2139220980 float_type->data.floating.bit_count != 64) {
2139320981 ir_add_error(ira, instruction->type, buf_sprintf("compiler TODO: add implementation of sqrt for '%s'", buf_ptr(&float_type->name)));
21394 return ira->codegen->builtin_types.entry_invalid;
20982 return ira->codegen->invalid_instruction;
2139520983 }
2139620984
2139720985 IrInstruction *result = ir_build_sqrt(&ira->new_irb, instruction->base.scope,
2139820986 instruction->base.source_node, nullptr, casted_op);
21399 ir_link_new_instruction(result, &instruction->base);
2140020987 result->value.type = float_type;
21401 return result->value.type;
20988 return result;
2140220989}
2140320990
21404static ZigType *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
20991static IrInstruction *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
2140520992 Error err;
21406 IrInstruction *target = instruction->target->other;
20993 IrInstruction *target = instruction->target->child;
2140720994 if (type_is_invalid(target->value.type))
21408 return ira->codegen->builtin_types.entry_invalid;
20995 return ira->codegen->invalid_instruction;
2140920996
2141020997 if (target->value.type->id != ZigTypeIdEnum) {
2141120998 ir_add_error(ira, instruction->target,
2141220999 buf_sprintf("expected enum, found type '%s'", buf_ptr(&target->value.type->name)));
21413 return ira->codegen->builtin_types.entry_invalid;
21000 return ira->codegen->invalid_instruction;
2141421001 }
2141521002
2141621003 if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusZeroBitsKnown)))
21417 return ira->codegen->builtin_types.entry_invalid;
21004 return ira->codegen->invalid_instruction;
2141821005
2141921006 ZigType *tag_type = target->value.type->data.enumeration.tag_int_type;
2142021007
21421 IrInstruction *result = ir_analyze_enum_to_int(ira, &instruction->base, target, tag_type);
21422 ir_link_new_instruction(result, &instruction->base);
21423 return result->value.type;
21008 return ir_analyze_enum_to_int(ira, &instruction->base, target, tag_type);
2142421009}
2142521010
21426static ZigType *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
21011static IrInstruction *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
2142721012 Error err;
21428 IrInstruction *dest_type_value = instruction->dest_type->other;
21013 IrInstruction *dest_type_value = instruction->dest_type->child;
2142921014 ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
2143021015 if (type_is_invalid(dest_type))
21431 return ira->codegen->builtin_types.entry_invalid;
21016 return ira->codegen->invalid_instruction;
2143221017
2143321018 if (dest_type->id != ZigTypeIdEnum) {
2143421019 ir_add_error(ira, instruction->dest_type,
2143521020 buf_sprintf("expected enum, found type '%s'", buf_ptr(&dest_type->name)));
21436 return ira->codegen->builtin_types.entry_invalid;
21021 return ira->codegen->invalid_instruction;
2143721022 }
2143821023
2143921024 if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
21440 return ira->codegen->builtin_types.entry_invalid;
21025 return ira->codegen->invalid_instruction;
2144121026
2144221027 ZigType *tag_type = dest_type->data.enumeration.tag_int_type;
2144321028
21444 IrInstruction *target = instruction->target->other;
21029 IrInstruction *target = instruction->target->child;
2144521030 if (type_is_invalid(target->value.type))
21446 return ira->codegen->builtin_types.entry_invalid;
21031 return ira->codegen->invalid_instruction;
2144721032
2144821033 IrInstruction *casted_target = ir_implicit_cast(ira, target, tag_type);
2144921034 if (type_is_invalid(casted_target->value.type))
21450 return ira->codegen->builtin_types.entry_invalid;
21035 return ira->codegen->invalid_instruction;
2145121036
21452 IrInstruction *result = ir_analyze_int_to_enum(ira, &instruction->base, casted_target, dest_type);
21453 ir_link_new_instruction(result, &instruction->base);
21454 return result->value.type;
21037 return ir_analyze_int_to_enum(ira, &instruction->base, casted_target, dest_type);
2145521038}
2145621039
21457static ZigType *ir_analyze_instruction_check_runtime_scope(IrAnalyze *ira, IrInstructionCheckRuntimeScope *instruction) {
21458 IrInstruction *block_comptime_inst = instruction->scope_is_comptime->other;
21040static IrInstruction *ir_analyze_instruction_check_runtime_scope(IrAnalyze *ira, IrInstructionCheckRuntimeScope *instruction) {
21041 IrInstruction *block_comptime_inst = instruction->scope_is_comptime->child;
2145921042 bool scope_is_comptime;
2146021043 if (!ir_resolve_bool(ira, block_comptime_inst, &scope_is_comptime))
21461 return ira->codegen->builtin_types.entry_invalid;
21044 return ira->codegen->invalid_instruction;
2146221045
21463 IrInstruction *is_comptime_inst = instruction->is_comptime->other;
21046 IrInstruction *is_comptime_inst = instruction->is_comptime->child;
2146421047 bool is_comptime;
2146521048 if (!ir_resolve_bool(ira, is_comptime_inst, &is_comptime))
21466 return ira->codegen->builtin_types.entry_invalid;
21049 return ira->codegen->invalid_instruction;
2146721050
2146821051 if (!scope_is_comptime && is_comptime) {
2146921052 ErrorMsg *msg = ir_add_error(ira, &instruction->base,
2147021053 buf_sprintf("comptime control flow inside runtime block"));
2147121054 add_error_note(ira->codegen, msg, block_comptime_inst->source_node,
2147221055 buf_sprintf("runtime block created here"));
21473 return ira->codegen->builtin_types.entry_invalid;
21056 return ira->codegen->invalid_instruction;
2147421057 }
2147521058
21476 ir_build_const_from(ira, &instruction->base);
21477 return ira->codegen->builtin_types.entry_void;
21059 return ir_const_void(ira, &instruction->base);
2147821060}
2147921061
21480static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
21062static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
2148121063 switch (instruction->id) {
2148221064 case IrInstructionIdInvalid:
2148321065 case IrInstructionIdWidenOrShorten:
......@@ -21761,19 +21343,11 @@ static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *ins
2176121343 zig_unreachable();
2176221344}
2176321345
21764static ZigType *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction) {
21765 ZigType *instruction_type = ir_analyze_instruction_nocast(ira, instruction);
21766 instruction->value.type = instruction_type;
21767
21768 if (instruction->other) {
21769 instruction->other->value.type = instruction_type;
21770 } else {
21771 assert(instruction_type->id == ZigTypeIdInvalid ||
21772 instruction_type->id == ZigTypeIdUnreachable);
21773 instruction->other = instruction;
21774 }
21775
21776 return instruction_type;
21346static IrInstruction *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *old_instruction) {
21347 IrInstruction *new_instruction = ir_analyze_instruction_nocast(ira, old_instruction);
21348 assert(new_instruction->value.type != nullptr);
21349 old_instruction->child = new_instruction;
21350 return new_instruction;
2177721351}
2177821352
2177921353// This function attempts to evaluate IR code while doing type checking and other analysis.
......@@ -21820,13 +21394,13 @@ ZigType *ir_analyze(CodeGen *codegen, IrExecutable *old_exec, IrExecutable *new_
2182021394 continue;
2182121395 }
2182221396
21823 ZigType *return_type = ir_analyze_instruction(ira, old_instruction);
21824 if (type_is_invalid(return_type) && ir_should_inline(new_exec, old_instruction->scope)) {
21397 IrInstruction *new_instruction = ir_analyze_instruction(ira, old_instruction);
21398 if (type_is_invalid(new_instruction->value.type) && ir_should_inline(new_exec, old_instruction->scope)) {
2182521399 return ira->codegen->builtin_types.entry_invalid;
2182621400 }
2182721401
2182821402 // unreachable instructions do their own control flow.
21829 if (return_type->id == ZigTypeIdUnreachable)
21403 if (new_instruction->value.type->id == ZigTypeIdUnreachable)
2183021404 continue;
2183121405
2183221406 ira->instruction_index += 1;