authorgravatar for matthew.h.borkowski@gmail.comMatthew Borkowski <matthew.h.borkowski@gmail.com> 2021-10-31 21:29:33-04:00
committergravatar for matthew.h.borkowski@gmail.comMatthew Borkowski <matthew.h.borkowski@gmail.com> 2021-11-01 05:09:19-04:00
log2561be2e34ecdbdb11b9de7790089d844739eaea
tree576644ece4e56b877345512c8ce9339442647c17
parent83dcfd62053a80024b1cb282fddf399a36c9c58e

astgen.zig: avoid temporary allocations in arrayInit* and structInit*, callExpr, errorSetDecl, typeOf, and builtinCall's compile_log branch

1 files changed, 162 insertions(+), 147 deletions(-)

src/AstGen.zig+162-147
......@@ -53,16 +53,30 @@ fn addExtra(astgen: *AstGen, extra: anytype) Allocator.Error!u32 {
5353fn addExtraAssumeCapacity(astgen: *AstGen, extra: anytype) u32 {
5454 const fields = std.meta.fields(@TypeOf(extra));
5555 const result = @intCast(u32, astgen.extra.items.len);
56 astgen.extra.items.len += fields.len;
57 setExtra(astgen, result, extra);
58 return result;
59}
60
61fn setExtra(astgen: *AstGen, index: usize, extra: anytype) void {
62 const fields = std.meta.fields(@TypeOf(extra));
63 var i = index;
5664 inline for (fields) |field| {
57 astgen.extra.appendAssumeCapacity(switch (field.field_type) {
65 astgen.extra.items[i] = switch (field.field_type) {
5866 u32 => @field(extra, field.name),
5967 Zir.Inst.Ref => @enumToInt(@field(extra, field.name)),
6068 i32 => @bitCast(u32, @field(extra, field.name)),
6169 Zir.Inst.Call.Flags => @bitCast(u32, @field(extra, field.name)),
6270 Zir.Inst.SwitchBlock.Bits => @bitCast(u32, @field(extra, field.name)),
6371 else => @compileError("bad field type"),
64 });
72 };
73 i += 1;
6574 }
75}
76
77fn reserveExtra(astgen: *AstGen, size: usize) Allocator.Error!u32 {
78 const result = @intCast(u32, astgen.extra.items.len);
79 try astgen.extra.resize(astgen.gpa, result + size);
6680 return result;
6781}
6882
......@@ -1307,18 +1321,18 @@ fn arrayInitExprRlNone(
13071321 tag: Zir.Inst.Tag,
13081322) InnerError!Zir.Inst.Ref {
13091323 const astgen = gz.astgen;
1310 const gpa = astgen.gpa;
1311 const elem_list = try gpa.alloc(Zir.Inst.Ref, elements.len);
1312 defer gpa.free(elem_list);
13131324
1314 for (elements) |elem_init, i| {
1315 elem_list[i] = try expr(gz, scope, .none, elem_init);
1316 }
1317 const init_inst = try gz.addPlNode(tag, node, Zir.Inst.MultiOp{
1318 .operands_len = @intCast(u32, elem_list.len),
1325 const payload_index = try addExtra(astgen, Zir.Inst.MultiOp{
1326 .operands_len = @intCast(u32, elements.len),
13191327 });
1320 try astgen.appendRefs(elem_list);
1321 return init_inst;
1328 var extra_index = try reserveExtra(astgen, elements.len);
1329
1330 for (elements) |elem_init| {
1331 const elem_ref = try expr(gz, scope, .none, elem_init);
1332 astgen.extra.items[extra_index] = @enumToInt(elem_ref);
1333 extra_index += 1;
1334 }
1335 return try gz.addPlNodePayloadIndex(tag, node, payload_index);
13221336}
13231337
13241338fn arrayInitExprRlTy(
......@@ -1330,21 +1344,19 @@ fn arrayInitExprRlTy(
13301344 tag: Zir.Inst.Tag,
13311345) InnerError!Zir.Inst.Ref {
13321346 const astgen = gz.astgen;
1333 const gpa = astgen.gpa;
13341347
1335 const elem_list = try gpa.alloc(Zir.Inst.Ref, elements.len);
1336 defer gpa.free(elem_list);
1348 const payload_index = try addExtra(astgen, Zir.Inst.MultiOp{
1349 .operands_len = @intCast(u32, elements.len),
1350 });
1351 var extra_index = try reserveExtra(astgen, elements.len);
13371352
13381353 const elem_rl: ResultLoc = .{ .ty = elem_ty_inst };
1339
1340 for (elements) |elem_init, i| {
1341 elem_list[i] = try expr(gz, scope, elem_rl, elem_init);
1354 for (elements) |elem_init| {
1355 const elem_ref = try expr(gz, scope, elem_rl, elem_init);
1356 astgen.extra.items[extra_index] = @enumToInt(elem_ref);
1357 extra_index += 1;
13421358 }
1343 const init_inst = try gz.addPlNode(tag, node, Zir.Inst.MultiOp{
1344 .operands_len = @intCast(u32, elem_list.len),
1345 });
1346 try astgen.appendRefs(elem_list);
1347 return init_inst;
1359 return try gz.addPlNodePayloadIndex(tag, node, payload_index);
13481360}
13491361
13501362fn arrayInitExprRlPtr(
......@@ -1375,23 +1387,22 @@ fn arrayInitExprRlPtrInner(
13751387 elements: []const Ast.Node.Index,
13761388) InnerError!Zir.Inst.Ref {
13771389 const astgen = gz.astgen;
1378 const gpa = astgen.gpa;
13791390
1380 const elem_ptr_list = try gpa.alloc(Zir.Inst.Index, elements.len);
1381 defer gpa.free(elem_ptr_list);
1391 const payload_index = try addExtra(astgen, Zir.Inst.Block{
1392 .body_len = @intCast(u32, elements.len),
1393 });
1394 var extra_index = try reserveExtra(astgen, elements.len);
13821395
13831396 for (elements) |elem_init, i| {
13841397 const elem_ptr = try gz.addPlNode(.elem_ptr_imm, elem_init, Zir.Inst.ElemPtrImm{
13851398 .ptr = result_ptr,
13861399 .index = @intCast(u32, i),
13871400 });
1388 elem_ptr_list[i] = refToIndex(elem_ptr).?;
1401 astgen.extra.items[extra_index] = refToIndex(elem_ptr).?;
1402 extra_index += 1;
13891403 _ = try expr(gz, scope, .{ .ptr = elem_ptr }, elem_init);
13901404 }
1391 _ = try gz.addPlNode(.validate_array_init, node, Zir.Inst.Block{
1392 .body_len = @intCast(u32, elem_ptr_list.len),
1393 });
1394 try astgen.extra.appendSlice(gpa, elem_ptr_list);
1405 _ = try gz.addPlNodePayloadIndex(.validate_array_init, node, payload_index);
13951406 return .void_value;
13961407}
13971408
......@@ -1505,30 +1516,25 @@ fn structInitExprRlNone(
15051516 tag: Zir.Inst.Tag,
15061517) InnerError!Zir.Inst.Ref {
15071518 const astgen = gz.astgen;
1508 const gpa = astgen.gpa;
15091519 const tree = astgen.tree;
15101520
1511 const fields_list = try gpa.alloc(Zir.Inst.StructInitAnon.Item, struct_init.ast.fields.len);
1512 defer gpa.free(fields_list);
1521 const payload_index = try addExtra(astgen, Zir.Inst.StructInitAnon{
1522 .fields_len = @intCast(u32, struct_init.ast.fields.len),
1523 });
1524 const field_size = @typeInfo(Zir.Inst.StructInitAnon.Item).Struct.fields.len;
1525 var extra_index: usize = try reserveExtra(astgen, struct_init.ast.fields.len * field_size);
15131526
1514 for (struct_init.ast.fields) |field_init, i| {
1527 for (struct_init.ast.fields) |field_init| {
15151528 const name_token = tree.firstToken(field_init) - 2;
15161529 const str_index = try astgen.identAsString(name_token);
1517
1518 fields_list[i] = .{
1530 setExtra(astgen, extra_index, Zir.Inst.StructInitAnon.Item{
15191531 .field_name = str_index,
15201532 .init = try expr(gz, scope, .none, field_init),
1521 };
1522 }
1523 const init_inst = try gz.addPlNode(tag, node, Zir.Inst.StructInitAnon{
1524 .fields_len = @intCast(u32, fields_list.len),
1525 });
1526 try astgen.extra.ensureUnusedCapacity(gpa, fields_list.len *
1527 @typeInfo(Zir.Inst.StructInitAnon.Item).Struct.fields.len);
1528 for (fields_list) |field| {
1529 _ = gz.astgen.addExtraAssumeCapacity(field);
1533 });
1534 extra_index += field_size;
15301535 }
1531 return init_inst;
1536
1537 return try gz.addPlNodePayloadIndex(tag, node, payload_index);
15321538}
15331539
15341540fn structInitExprRlPtr(
......@@ -1559,26 +1565,26 @@ fn structInitExprRlPtrInner(
15591565 result_ptr: Zir.Inst.Ref,
15601566) InnerError!Zir.Inst.Ref {
15611567 const astgen = gz.astgen;
1562 const gpa = astgen.gpa;
15631568 const tree = astgen.tree;
15641569
1565 const field_ptr_list = try gpa.alloc(Zir.Inst.Index, struct_init.ast.fields.len);
1566 defer gpa.free(field_ptr_list);
1570 const payload_index = try addExtra(astgen, Zir.Inst.Block{
1571 .body_len = @intCast(u32, struct_init.ast.fields.len),
1572 });
1573 var extra_index = try reserveExtra(astgen, struct_init.ast.fields.len);
15671574
1568 for (struct_init.ast.fields) |field_init, i| {
1575 for (struct_init.ast.fields) |field_init| {
15691576 const name_token = tree.firstToken(field_init) - 2;
15701577 const str_index = try astgen.identAsString(name_token);
15711578 const field_ptr = try gz.addPlNode(.field_ptr, field_init, Zir.Inst.Field{
15721579 .lhs = result_ptr,
15731580 .field_name_start = str_index,
15741581 });
1575 field_ptr_list[i] = refToIndex(field_ptr).?;
1582 astgen.extra.items[extra_index] = refToIndex(field_ptr).?;
1583 extra_index += 1;
15761584 _ = try expr(gz, scope, .{ .ptr = field_ptr }, field_init);
15771585 }
1578 _ = try gz.addPlNode(.validate_struct_init, node, Zir.Inst.Block{
1579 .body_len = @intCast(u32, field_ptr_list.len),
1580 });
1581 try astgen.extra.appendSlice(gpa, field_ptr_list);
1586
1587 _ = try gz.addPlNodePayloadIndex(.validate_struct_init, node, payload_index);
15821588 return Zir.Inst.Ref.void_value;
15831589}
15841590
......@@ -1591,34 +1597,29 @@ fn structInitExprRlTy(
15911597 tag: Zir.Inst.Tag,
15921598) InnerError!Zir.Inst.Ref {
15931599 const astgen = gz.astgen;
1594 const gpa = astgen.gpa;
15951600 const tree = astgen.tree;
15961601
1597 const fields_list = try gpa.alloc(Zir.Inst.StructInit.Item, struct_init.ast.fields.len);
1598 defer gpa.free(fields_list);
1602 const payload_index = try addExtra(astgen, Zir.Inst.StructInit{
1603 .fields_len = @intCast(u32, struct_init.ast.fields.len),
1604 });
1605 const field_size = @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len;
1606 var extra_index: usize = try reserveExtra(astgen, struct_init.ast.fields.len * field_size);
15991607
1600 for (struct_init.ast.fields) |field_init, i| {
1608 for (struct_init.ast.fields) |field_init| {
16011609 const name_token = tree.firstToken(field_init) - 2;
16021610 const str_index = try astgen.identAsString(name_token);
1603
16041611 const field_ty_inst = try gz.addPlNode(.field_type, field_init, Zir.Inst.FieldType{
16051612 .container_type = ty_inst,
16061613 .name_start = str_index,
16071614 });
1608 fields_list[i] = .{
1615 setExtra(astgen, extra_index, Zir.Inst.StructInit.Item{
16091616 .field_type = refToIndex(field_ty_inst).?,
16101617 .init = try expr(gz, scope, .{ .ty = field_ty_inst }, field_init),
1611 };
1612 }
1613 const init_inst = try gz.addPlNode(tag, node, Zir.Inst.StructInit{
1614 .fields_len = @intCast(u32, fields_list.len),
1615 });
1616 try astgen.extra.ensureUnusedCapacity(gpa, fields_list.len *
1617 @typeInfo(Zir.Inst.StructInit.Item).Struct.fields.len);
1618 for (fields_list) |field| {
1619 _ = gz.astgen.addExtraAssumeCapacity(field);
1618 });
1619 extra_index += field_size;
16201620 }
1621 return init_inst;
1621
1622 return try gz.addPlNodePayloadIndex(tag, node, payload_index);
16221623}
16231624
16241625/// This calls expr in a comptime scope, and is intended to be called as a helper function.
......@@ -4851,20 +4852,18 @@ fn errorSetDecl(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir
48514852 const main_tokens = tree.nodes.items(.main_token);
48524853 const token_tags = tree.tokens.items(.tag);
48534854
4854 var field_names: std.ArrayListUnmanaged(u32) = .{};
4855 defer field_names.deinit(gpa);
4856
4855 const payload_index = try reserveExtra(astgen, @typeInfo(Zir.Inst.ErrorSetDecl).Struct.fields.len);
4856 var fields_len: usize = 0;
48574857 {
48584858 const error_token = main_tokens[node];
48594859 var tok_i = error_token + 2;
4860 var field_i: usize = 0;
48614860 while (true) : (tok_i += 1) {
48624861 switch (token_tags[tok_i]) {
48634862 .doc_comment, .comma => {},
48644863 .identifier => {
48654864 const str_index = try astgen.identAsString(tok_i);
4866 try field_names.append(gpa, str_index);
4867 field_i += 1;
4865 try astgen.extra.append(gpa, str_index);
4866 fields_len += 1;
48684867 },
48694868 .r_brace => break,
48704869 else => unreachable,
......@@ -4872,10 +4871,10 @@ fn errorSetDecl(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir
48724871 }
48734872 }
48744873
4875 const result = try gz.addPlNode(.error_set_decl, node, Zir.Inst.ErrorSetDecl{
4876 .fields_len = @intCast(u32, field_names.items.len),
4874 setExtra(astgen, payload_index, Zir.Inst.ErrorSetDecl{
4875 .fields_len = @intCast(u32, fields_len),
48774876 });
4878 try astgen.extra.appendSlice(gpa, field_names.items);
4877 const result = try gz.addPlNodePayloadIndex(.error_set_decl, node, payload_index);
48794878 return rvalue(gz, rl, result, node);
48804879}
48814880
......@@ -7196,13 +7195,18 @@ fn typeOf(
71967195 const result = try gz.addUnNode(.typeof, expr_result, node);
71977196 return rvalue(gz, rl, result, node);
71987197 }
7199 const arena = gz.astgen.arena;
7200 var items = try arena.alloc(Zir.Inst.Ref, params.len);
7201 for (params) |param, param_i| {
7202 items[param_i] = try reachableExpr(gz, scope, .none, param, node);
7198
7199 const payload_index = try addExtra(gz.astgen, Zir.Inst.NodeMultiOp{
7200 .src_node = gz.nodeIndexToRelative(node),
7201 });
7202 var extra_index = try reserveExtra(gz.astgen, params.len);
7203 for (params) |param| {
7204 const param_ref = try reachableExpr(gz, scope, .none, param, node);
7205 gz.astgen.extra.items[extra_index] = @enumToInt(param_ref);
7206 extra_index += 1;
72037207 }
72047208
7205 const result = try gz.addExtendedMultiOp(.typeof_peer, node, items);
7209 const result = try gz.addExtendedMultiOpPayloadIndex(.typeof_peer, payload_index, params.len);
72067210 return rvalue(gz, rl, result, node);
72077211}
72087212
......@@ -7259,12 +7263,16 @@ fn builtinCall(
72597263 return rvalue(gz, rl, result, node);
72607264 },
72617265 .compile_log => {
7262 const arg_refs = try astgen.gpa.alloc(Zir.Inst.Ref, params.len);
7263 defer astgen.gpa.free(arg_refs);
7264
7265 for (params) |param, i| arg_refs[i] = try expr(gz, scope, .none, param);
7266
7267 const result = try gz.addExtendedMultiOp(.compile_log, node, arg_refs);
7266 const payload_index = try addExtra(gz.astgen, Zir.Inst.NodeMultiOp{
7267 .src_node = gz.nodeIndexToRelative(node),
7268 });
7269 var extra_index = try reserveExtra(gz.astgen, params.len);
7270 for (params) |param| {
7271 const param_ref = try expr(gz, scope, .none, param);
7272 astgen.extra.items[extra_index] = @enumToInt(param_ref);
7273 extra_index += 1;
7274 }
7275 const result = try gz.addExtendedMultiOpPayloadIndex(.compile_log,payload_index, params.len);
72687276 return rvalue(gz, rl, result, node);
72697277 },
72707278 .field => {
......@@ -7974,22 +7982,6 @@ fn callExpr(
79747982 const astgen = gz.astgen;
79757983
79767984 const callee = try calleeExpr(gz, scope, call.ast.fn_expr);
7977
7978 // A large proportion of calls have 5 or less arguments, due to this preventing allocations
7979 // for calls with few arguments has a sizeable effect on the aggregated runtime of this function
7980 var arg_buffer: [5]Zir.Inst.Ref = undefined;
7981 const args: []Zir.Inst.Ref = if (call.ast.params.len <= arg_buffer.len)
7982 arg_buffer[0..call.ast.params.len]
7983 else
7984 try astgen.gpa.alloc(Zir.Inst.Ref, call.ast.params.len);
7985 defer if (call.ast.params.len > arg_buffer.len) astgen.gpa.free(args);
7986
7987 for (call.ast.params) |param_node, i| {
7988 // Parameters are always temporary values, they have no
7989 // meaningful result location. Sema will coerce them.
7990 args[i] = try expr(gz, scope, .none, param_node);
7991 }
7992
79937985 const modifier: std.builtin.CallOptions.Modifier = blk: {
79947986 if (gz.force_comptime) {
79957987 break :blk .compile_time;
......@@ -8002,7 +7994,28 @@ fn callExpr(
80027994 }
80037995 break :blk .auto;
80047996 };
8005 const call_inst = try gz.addCall(modifier, callee, args, node);
7997
7998 assert(callee != .none);
7999 assert(node != 0);
8000
8001 const payload_index = try addExtra(astgen, Zir.Inst.Call{
8002 .callee = callee,
8003 .flags = .{
8004 .packed_modifier = @intCast(Zir.Inst.Call.Flags.PackedModifier, @enumToInt(modifier)),
8005 .args_len = @intCast(Zir.Inst.Call.Flags.PackedArgsLen, call.ast.params.len),
8006 },
8007 });
8008 var extra_index = try reserveExtra(astgen, call.ast.params.len);
8009
8010 for (call.ast.params) |param_node| {
8011 // Parameters are always temporary values, they have no
8012 // meaningful result location. Sema will coerce them.
8013 const arg_ref = try expr(gz, scope, .none, param_node);
8014 astgen.extra.items[extra_index] = @enumToInt(arg_ref);
8015 extra_index += 1;
8016 }
8017
8018 const call_inst = try gz.addPlNodePayloadIndex(.call, node, payload_index);
80068019 return rvalue(gz, rl, call_inst, node); // TODO function call with result location
80078020}
80088021
......@@ -9765,44 +9778,6 @@ const GenZir = struct {
97659778 return indexToRef(new_index);
97669779 }
97679780
9768 fn addCall(
9769 gz: *GenZir,
9770 modifier: std.builtin.CallOptions.Modifier,
9771 callee: Zir.Inst.Ref,
9772 args: []const Zir.Inst.Ref,
9773 /// Absolute node index. This function does the conversion to offset from Decl.
9774 src_node: Ast.Node.Index,
9775 ) !Zir.Inst.Ref {
9776 assert(callee != .none);
9777 assert(src_node != 0);
9778 const gpa = gz.astgen.gpa;
9779 const Call = Zir.Inst.Call;
9780 try gz.instructions.ensureUnusedCapacity(gpa, 1);
9781 try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1);
9782 try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Call).Struct.fields.len +
9783 args.len);
9784
9785 const payload_index = gz.astgen.addExtraAssumeCapacity(Call{
9786 .callee = callee,
9787 .flags = .{
9788 .packed_modifier = @intCast(Call.Flags.PackedModifier, @enumToInt(modifier)),
9789 .args_len = @intCast(Call.Flags.PackedArgsLen, args.len),
9790 },
9791 });
9792 gz.astgen.appendRefsAssumeCapacity(args);
9793
9794 const new_index = @intCast(Zir.Inst.Index, gz.astgen.instructions.len);
9795 gz.astgen.instructions.appendAssumeCapacity(.{
9796 .tag = .call,
9797 .data = .{ .pl_node = .{
9798 .src_node = gz.nodeIndexToRelative(src_node),
9799 .payload_index = payload_index,
9800 } },
9801 });
9802 gz.instructions.appendAssumeCapacity(new_index);
9803 return indexToRef(new_index);
9804 }
9805
98069781 /// Note that this returns a `Zir.Inst.Index` not a ref.
98079782 /// Leaves the `payload_index` field undefined.
98089783 fn addBoolBr(
......@@ -9902,6 +9877,22 @@ const GenZir = struct {
99029877 return indexToRef(new_index);
99039878 }
99049879
9880 fn addPlNodePayloadIndex(
9881 gz: *GenZir,
9882 tag: Zir.Inst.Tag,
9883 /// Absolute node index. This function does the conversion to offset from Decl.
9884 src_node: Ast.Node.Index,
9885 payload_index: u32,
9886 ) !Zir.Inst.Ref {
9887 return try gz.add(.{
9888 .tag = tag,
9889 .data = .{ .pl_node = .{
9890 .src_node = gz.nodeIndexToRelative(src_node),
9891 .payload_index = payload_index,
9892 } },
9893 });
9894 }
9895
99059896 fn addParam(
99069897 gz: *GenZir,
99079898 tag: Zir.Inst.Tag,
......@@ -9991,6 +9982,30 @@ const GenZir = struct {
99919982 return indexToRef(new_index);
99929983 }
99939984
9985 fn addExtendedMultiOpPayloadIndex(
9986 gz: *GenZir,
9987 opcode: Zir.Inst.Extended,
9988 payload_index: u32,
9989 trailing_len: usize,
9990 ) !Zir.Inst.Ref {
9991 const astgen = gz.astgen;
9992 const gpa = astgen.gpa;
9993
9994 try gz.instructions.ensureUnusedCapacity(gpa, 1);
9995 try astgen.instructions.ensureUnusedCapacity(gpa, 1);
9996 const new_index = @intCast(Zir.Inst.Index, astgen.instructions.len);
9997 astgen.instructions.appendAssumeCapacity(.{
9998 .tag = .extended,
9999 .data = .{ .extended = .{
10000 .opcode = opcode,
10001 .small = @intCast(u16, trailing_len),
10002 .operand = payload_index,
10003 } },
10004 });
10005 gz.instructions.appendAssumeCapacity(new_index);
10006 return indexToRef(new_index);
10007 }
10008
999410009 fn addUnTok(
999510010 gz: *GenZir,
999610011 tag: Zir.Inst.Tag,