authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-04-29 12:23:46+03:00
committergravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2022-04-30 01:06:01+03:00
log596f7df02e78adf334eed4a1f14eafa31ca611b9
treec2e3dc7082a0b0c8d870506820d10c708c906934
parent1d455896cb24165c5a3e0b3e10934c60a285589d

Zir: turn extended func into func_extended

5 files changed, 75 insertions(+), 80 deletions(-)

src/AstGen.zig+15-14
......@@ -72,6 +72,7 @@ fn setExtra(astgen: *AstGen, index: usize, extra: anytype) void {
7272 i32 => @bitCast(u32, @field(extra, field.name)),
7373 Zir.Inst.Call.Flags => @bitCast(u32, @field(extra, field.name)),
7474 Zir.Inst.SwitchBlock.Bits => @bitCast(u32, @field(extra, field.name)),
75 Zir.Inst.ExtendedFunc.Bits => @bitCast(u32, @field(extra, field.name)),
7576 else => @compileError("bad field type"),
7677 };
7778 i += 1;
......@@ -2245,6 +2246,7 @@ fn unusedResultExpr(gz: *GenZir, scope: *Scope, statement: Ast.Node.Index) Inner
22452246 .field_val_named,
22462247 .func,
22472248 .func_inferred,
2249 .func_extended,
22482250 .int,
22492251 .int_big,
22502252 .float,
......@@ -10023,10 +10025,18 @@ const GenZir = struct {
1002310025 @boolToInt(args.cc != .none),
1002410026 );
1002510027 const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.ExtendedFunc{
10026 .src_node = gz.nodeIndexToRelative(args.src_node),
1002710028 .param_block = args.param_block,
1002810029 .ret_body_len = @intCast(u32, ret_ty.len),
1002910030 .body_len = @intCast(u32, body.len),
10031 .bits = .{
10032 .is_var_args = args.is_var_args,
10033 .is_inferred_error = args.is_inferred_error,
10034 .has_lib_name = args.lib_name != 0,
10035 .has_cc = args.cc != .none,
10036 .has_align = args.align_inst != .none,
10037 .is_test = args.is_test,
10038 .is_extern = args.is_extern,
10039 },
1003010040 });
1003110041 if (args.lib_name != 0) {
1003210042 astgen.extra.appendAssumeCapacity(args.lib_name);
......@@ -10050,19 +10060,10 @@ const GenZir = struct {
1005010060 astgen.instructions.items(.data)[args.ret_br].@"break".block_inst = new_index;
1005110061 }
1005210062 astgen.instructions.appendAssumeCapacity(.{
10053 .tag = .extended,
10054 .data = .{ .extended = .{
10055 .opcode = .func,
10056 .small = @bitCast(u16, Zir.Inst.ExtendedFunc.Small{
10057 .is_var_args = args.is_var_args,
10058 .is_inferred_error = args.is_inferred_error,
10059 .has_lib_name = args.lib_name != 0,
10060 .has_cc = args.cc != .none,
10061 .has_align = args.align_inst != .none,
10062 .is_test = args.is_test,
10063 .is_extern = args.is_extern,
10064 }),
10065 .operand = payload_index,
10063 .tag = .func_extended,
10064 .data = .{ .pl_node = .{
10065 .src_node = gz.nodeIndexToRelative(args.src_node),
10066 .payload_index = payload_index,
1006610067 } },
1006710068 });
1006810069 gz.instructions.appendAssumeCapacity(new_index);
src/Module.zig+4-4
......@@ -1532,10 +1532,10 @@ pub const Fn = struct {
15321532 switch (zir_tags[func.zir_body_inst]) {
15331533 .func => return false,
15341534 .func_inferred => return true,
1535 .extended => {
1536 const extended = zir.instructions.items(.data)[func.zir_body_inst].extended;
1537 const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
1538 return small.is_inferred_error;
1535 .func_extended => {
1536 const inst_data = zir.instructions.items(.data)[func.zir_body_inst].pl_node;
1537 const extra = zir.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
1538 return extra.data.bits.is_inferred_error;
15391539 },
15401540 else => unreachable,
15411541 }
src/Sema.zig+14-18
......@@ -745,6 +745,7 @@ fn analyzeBodyInner(
745745 .field_call_bind => try sema.zirFieldCallBind(block, inst),
746746 .func => try sema.zirFunc(block, inst, false),
747747 .func_inferred => try sema.zirFunc(block, inst, true),
748 .func_extended => try sema.zirFuncExtended(block, inst),
748749 .import => try sema.zirImport(block, inst),
749750 .indexable_ptr_len => try sema.zirIndexablePtrLen(block, inst),
750751 .int => try sema.zirInt(block, inst),
......@@ -911,7 +912,6 @@ fn analyzeBodyInner(
911912 const extended = datas[inst].extended;
912913 break :ext switch (extended.opcode) {
913914 // zig fmt: off
914 .func => try sema.zirFuncExtended( block, extended, inst),
915915 .variable => try sema.zirVarExtended( block, extended),
916916 .struct_decl => try sema.zirStructDecl( block, extended, inst),
917917 .enum_decl => try sema.zirEnumDecl( block, extended),
......@@ -16099,37 +16099,33 @@ fn zirVarExtended(
1609916099 return result;
1610016100}
1610116101
16102fn zirFuncExtended(
16103 sema: *Sema,
16104 block: *Block,
16105 extended: Zir.Inst.Extended.InstData,
16106 inst: Zir.Inst.Index,
16107) CompileError!Air.Inst.Ref {
16102fn zirFuncExtended(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
1610816103 const tracy = trace(@src());
1610916104 defer tracy.end();
1611016105
16111 const extra = sema.code.extraData(Zir.Inst.ExtendedFunc, extended.operand);
16112 const src: LazySrcLoc = .{ .node_offset = extra.data.src_node };
16113 const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = extra.data.src_node };
16106 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
16107 const src = inst_data.src();
16108 const extra = sema.code.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
16109
16110 const cc_src: LazySrcLoc = .{ .node_offset_fn_type_cc = inst_data.src_node };
1611416111 const align_src: LazySrcLoc = src; // TODO add a LazySrcLoc that points at align
16115 const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
1611616112
1611716113 var extra_index: usize = extra.end;
1611816114
16119 const lib_name: ?[]const u8 = if (small.has_lib_name) blk: {
16115 const lib_name: ?[]const u8 = if (extra.data.bits.has_lib_name) blk: {
1612016116 const lib_name = sema.code.nullTerminatedString(sema.code.extra[extra_index]);
1612116117 extra_index += 1;
1612216118 break :blk lib_name;
1612316119 } else null;
1612416120
16125 const cc: std.builtin.CallingConvention = if (small.has_cc) blk: {
16121 const cc: std.builtin.CallingConvention = if (extra.data.bits.has_cc) blk: {
1612616122 const cc_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
1612716123 extra_index += 1;
1612816124 const cc_tv = try sema.resolveInstConst(block, cc_src, cc_ref);
1612916125 break :blk cc_tv.val.toEnum(std.builtin.CallingConvention);
1613016126 } else .Unspecified;
1613116127
16132 const align_val: Value = if (small.has_align) blk: {
16128 const align_val: Value = if (extra.data.bits.has_align) blk: {
1613316129 const align_ref = @intToEnum(Zir.Inst.Ref, sema.code.extra[extra_index]);
1613416130 extra_index += 1;
1613516131 const align_tv = try sema.resolveInstConst(block, align_src, align_ref);
......@@ -16146,13 +16142,13 @@ fn zirFuncExtended(
1614616142 src_locs = sema.code.extraData(Zir.Inst.Func.SrcLocs, extra_index).data;
1614716143 }
1614816144
16149 const is_var_args = small.is_var_args;
16150 const is_inferred_error = small.is_inferred_error;
16151 const is_extern = small.is_extern;
16145 const is_var_args = extra.data.bits.is_var_args;
16146 const is_inferred_error = extra.data.bits.is_inferred_error;
16147 const is_extern = extra.data.bits.is_extern;
1615216148
1615316149 return sema.funcCommon(
1615416150 block,
16155 extra.data.src_node,
16151 inst_data.src_node,
1615616152 inst,
1615716153 ret_ty_body,
1615816154 cc,
src/Zir.zig+30-32
......@@ -73,6 +73,7 @@ pub fn extraData(code: Zir, comptime T: type, index: usize) struct { data: T, en
7373 i32 => @bitCast(i32, code.extra[i]),
7474 Inst.Call.Flags => @bitCast(Inst.Call.Flags, code.extra[i]),
7575 Inst.SwitchBlock.Bits => @bitCast(Inst.SwitchBlock.Bits, code.extra[i]),
76 Inst.ExtendedFunc.Bits => @bitCast(Inst.ExtendedFunc.Bits, code.extra[i]),
7677 else => @compileError("bad field type"),
7778 };
7879 i += 1;
......@@ -415,6 +416,10 @@ pub const Inst = struct {
415416 func,
416417 /// Same as `func` but has an inferred error set.
417418 func_inferred,
419 /// Represents a function declaration or function prototype, depending on
420 /// whether body_len is 0.
421 /// Uses the `pl_node` union field. `payload_index` points to a `ExtendedFunc`.
422 func_extended,
418423 /// Implements the `@import` builtin.
419424 /// Uses the `str_tok` field.
420425 import,
......@@ -1062,6 +1067,7 @@ pub const Inst = struct {
10621067 .field_val_named,
10631068 .func,
10641069 .func_inferred,
1070 .func_extended,
10651071 .has_decl,
10661072 .int,
10671073 .int_big,
......@@ -1347,6 +1353,7 @@ pub const Inst = struct {
13471353 .field_val_named,
13481354 .func,
13491355 .func_inferred,
1356 .func_extended,
13501357 .has_decl,
13511358 .int,
13521359 .int_big,
......@@ -1601,6 +1608,7 @@ pub const Inst = struct {
16011608 .field_call_bind = .pl_node,
16021609 .func = .pl_node,
16031610 .func_inferred = .pl_node,
1611 .func_extended = .pl_node,
16041612 .import = .str_tok,
16051613 .int = .int,
16061614 .int_big = .str,
......@@ -1802,11 +1810,6 @@ pub const Inst = struct {
18021810 /// Rarer instructions are here; ones that do not fit in the 8-bit `Tag` enum.
18031811 /// `noreturn` instructions may not go here; they must be part of the main `Tag` enum.
18041812 pub const Extended = enum(u16) {
1805 /// Represents a function declaration or function prototype, depending on
1806 /// whether body_len is 0.
1807 /// `operand` is payload index to `ExtendedFunc`.
1808 /// `small` is `ExtendedFunc.Small`.
1809 func,
18101813 /// Declares a global variable.
18111814 /// `operand` is payload index to `ExtendedVar`.
18121815 /// `small` is `ExtendedVar.Small`.
......@@ -2621,14 +2624,14 @@ pub const Inst = struct {
26212624 /// 4. body: Index // for each body_len
26222625 /// 5. src_locs: Func.SrcLocs // if body_len != 0
26232626 pub const ExtendedFunc = struct {
2624 src_node: i32,
26252627 /// If this is 0 it means a void return type.
26262628 ret_body_len: u32,
26272629 /// Points to the block that contains the param instructions for this function.
26282630 param_block: Index,
26292631 body_len: u32,
2632 bits: Bits,
26302633
2631 pub const Small = packed struct {
2634 pub const Bits = packed struct {
26322635 is_var_args: bool,
26332636 is_inferred_error: bool,
26342637 has_lib_name: bool,
......@@ -2636,7 +2639,7 @@ pub const Inst = struct {
26362639 has_align: bool,
26372640 is_test: bool,
26382641 is_extern: bool,
2639 _: u9 = undefined,
2642 _: u25 = undefined,
26402643 };
26412644 };
26422645
......@@ -3460,14 +3463,11 @@ pub fn declIterator(zir: Zir, decl_inst: u32) DeclIterator {
34603463 switch (tags[decl_inst]) {
34613464 // Functions are allowed and yield no iterations.
34623465 // There is one case matching this in the extended instruction set below.
3463 .func,
3464 .func_inferred,
3465 => return declIteratorInner(zir, 0, 0),
3466 .func, .func_inferred, .func_extended => return declIteratorInner(zir, 0, 0),
34663467
34673468 .extended => {
34683469 const extended = datas[decl_inst].extended;
34693470 switch (extended.opcode) {
3470 .func => return declIteratorInner(zir, 0, 0),
34713471 .struct_decl => {
34723472 const small = @bitCast(Inst.StructDecl.Small, extended.small);
34733473 var extra_index: usize = extended.operand;
......@@ -3572,21 +3572,21 @@ fn findDeclsInner(
35723572 const body = zir.extra[extra.end..][0..extra.data.body_len];
35733573 return zir.findDeclsBody(list, body);
35743574 },
3575 .func_extended => {
3576 try list.append(inst);
3577
3578 const inst_data = datas[inst].pl_node;
3579 const extra = zir.extraData(Inst.ExtendedFunc, inst_data.payload_index);
3580 var extra_index: usize = extra.end;
3581 extra_index += @boolToInt(extra.data.bits.has_lib_name);
3582 extra_index += @boolToInt(extra.data.bits.has_cc);
3583 extra_index += @boolToInt(extra.data.bits.has_align);
3584 const body = zir.extra[extra_index..][0..extra.data.body_len];
3585 return zir.findDeclsBody(list, body);
3586 },
35753587 .extended => {
35763588 const extended = datas[inst].extended;
35773589 switch (extended.opcode) {
3578 .func => {
3579 try list.append(inst);
3580
3581 const extra = zir.extraData(Inst.ExtendedFunc, extended.operand);
3582 const small = @bitCast(Inst.ExtendedFunc.Small, extended.small);
3583 var extra_index: usize = extra.end;
3584 extra_index += @boolToInt(small.has_lib_name);
3585 extra_index += @boolToInt(small.has_cc);
3586 extra_index += @boolToInt(small.has_align);
3587 const body = zir.extra[extra_index..][0..extra.data.body_len];
3588 return zir.findDeclsBody(list, body);
3589 },
35903590
35913591 // Decl instructions are interesting but have no body.
35923592 // TODO yes they do have a body actually. recurse over them just like block instructions.
......@@ -3733,15 +3733,13 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
37333733 .body = body,
37343734 };
37353735 },
3736 .extended => blk: {
3737 const extended = datas[fn_inst].extended;
3738 assert(extended.opcode == .func);
3739 const extra = zir.extraData(Inst.ExtendedFunc, extended.operand);
3740 const small = @bitCast(Inst.ExtendedFunc.Small, extended.small);
3736 .func_extended => blk: {
3737 const inst_data = datas[fn_inst].pl_node;
3738 const extra = zir.extraData(Inst.ExtendedFunc, inst_data.payload_index);
37413739 var extra_index: usize = extra.end;
3742 extra_index += @boolToInt(small.has_lib_name);
3743 extra_index += @boolToInt(small.has_cc);
3744 extra_index += @boolToInt(small.has_align);
3740 extra_index += @boolToInt(extra.data.bits.has_lib_name);
3741 extra_index += @boolToInt(extra.data.bits.has_cc);
3742 extra_index += @boolToInt(extra.data.bits.has_align);
37453743 const ret_ty_body = zir.extra[extra_index..][0..extra.data.ret_body_len];
37463744 extra_index += ret_ty_body.len;
37473745 const body = zir.extra[extra_index..][0..extra.data.body_len];
src/print_zir.zig+12-12
......@@ -429,6 +429,7 @@ const Writer = struct {
429429
430430 .func => try self.writeFunc(stream, inst, false),
431431 .func_inferred => try self.writeFunc(stream, inst, true),
432 .func_extended => try self.writeFuncExtended(stream, inst),
432433
433434 .@"unreachable" => try self.writeUnreachable(stream, inst),
434435
......@@ -469,7 +470,6 @@ const Writer = struct {
469470 },
470471
471472 .@"asm" => try self.writeAsm(stream, extended),
472 .func => try self.writeFuncExtended(stream, extended),
473473 .variable => try self.writeVarExtended(stream, extended),
474474 .alloc => try self.writeAllocExtended(stream, extended),
475475
......@@ -1920,24 +1920,24 @@ const Writer = struct {
19201920 );
19211921 }
19221922
1923 fn writeFuncExtended(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
1924 const extra = self.code.extraData(Zir.Inst.ExtendedFunc, extended.operand);
1925 const src: LazySrcLoc = .{ .node_offset = extra.data.src_node };
1926 const small = @bitCast(Zir.Inst.ExtendedFunc.Small, extended.small);
1923 fn writeFuncExtended(self: *Writer, stream: anytype, inst: Zir.Inst.Index) !void {
1924 const inst_data = self.code.instructions.items(.data)[inst].pl_node;
1925 const extra = self.code.extraData(Zir.Inst.ExtendedFunc, inst_data.payload_index);
1926 const src = inst_data.src();
19271927
19281928 var extra_index: usize = extra.end;
1929 if (small.has_lib_name) {
1929 if (extra.data.bits.has_lib_name) {
19301930 const lib_name = self.code.nullTerminatedString(self.code.extra[extra_index]);
19311931 extra_index += 1;
19321932 try stream.print("lib_name=\"{}\", ", .{std.zig.fmtEscapes(lib_name)});
19331933 }
1934 try self.writeFlag(stream, "test, ", small.is_test);
1935 const cc: Zir.Inst.Ref = if (!small.has_cc) .none else blk: {
1934 try self.writeFlag(stream, "test, ", extra.data.bits.is_test);
1935 const cc: Zir.Inst.Ref = if (!extra.data.bits.has_cc) .none else blk: {
19361936 const cc = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
19371937 extra_index += 1;
19381938 break :blk cc;
19391939 };
1940 const align_inst: Zir.Inst.Ref = if (!small.has_align) .none else blk: {
1940 const align_inst: Zir.Inst.Ref = if (!extra.data.bits.has_align) .none else blk: {
19411941 const align_inst = @intToEnum(Zir.Inst.Ref, self.code.extra[extra_index]);
19421942 extra_index += 1;
19431943 break :blk align_inst;
......@@ -1956,9 +1956,9 @@ const Writer = struct {
19561956 return self.writeFuncCommon(
19571957 stream,
19581958 ret_ty_body,
1959 small.is_inferred_error,
1960 small.is_var_args,
1961 small.is_extern,
1959 extra.data.bits.is_inferred_error,
1960 extra.data.bits.is_var_args,
1961 extra.data.bits.is_extern,
19621962 cc,
19631963 align_inst,
19641964 body,