Commit 6707a5efeea1ab973c3274495bb0a5640e4f568b | zig

lib/std/debug.zig+39-38

...	...	@@ -39,7 +39,7 @@ pub const cpu_context = @import("debug/cpu_context.zig");
39	39	/// pub fn deinit(si: *SelfInfo, io: Io) void;
40	40	///
41	41	/// /// Appends the symbols for the instruction at `address` to `symbols`.
42		/// pub fn getSymbols(si: SelfInfo, io: Io, gpa: Allocator, address: usize, include_inline_callers: bool, symbols: std.ArrayList(Symbol)) SelfInfoError!void;
	42	/// pub fn getSymbols(si: SelfInfo, io: Io, symbol_allocator: Allocator, text_arena: Allocator, address: usize, include_inline_callers: bool, symbols: std.ArrayList(Symbol)) SelfInfoError!void;
43	43	/// /// Returns a name for the "module" (e.g. shared library or executable image) containing `address`.
44	44	/// pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) SelfInfoError![]const u8;
45	45	/// pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) SelfInfoError!usize;
...	...	@@ -229,11 +229,6 @@ pub const Symbol = struct {
229	229	.compile_unit_name = null,
230	230	.source_location = null,
231	231	};
232
233		pub fn deinit(self: *Symbol, gpa: Allocator) void {
234		if (self.source_location) \|sl\| gpa.free(sl.file_name);
235		self.* = undefined;
236		}
237	232	};
238	233
239	234	/// Deprecated because it returns the optimization mode of the standard
...	...	@@ -699,6 +694,10 @@ pub noinline fn captureCurrentStackTrace(options: StackUnwindOptions, addr_buf:
699	694	/// See `captureCurrentStackTrace` to capture the trace addresses into a buffer instead of printing.
700	695	pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Terminal) Writer.Error!void {
701	696	const writer = t.writer;
	697
	698	var text_arena: std.heap.ArenaAllocator = .init(getDebugInfoAllocator());
	699	defer text_arena.deinit();
	700
702	701	if (!std.options.allow_stack_tracing) {
703	702	t.setColor(.dim) catch {};
704	703	try writer.print("Cannot print stack trace: stack tracing is disabled\n", .{});
...	...	@@ -776,7 +775,7 @@ pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, t: Io.Termin
776	775	}
777	776	// `ret_addr` is the return address, which is after the function call.
778	777	// Subtract 1 to get an address in the function call for a better source location.
779		try printSourceAtAddress(io, di, t, .{
	778	try printSourceAtAddress(io, &text_arena, di, t, .{
780	779	.address = ret_addr -\| StackIterator.ra_call_offset,
781	780	.resolve_inline_callers = true,
782	781	});
...	...	@@ -832,6 +831,9 @@ fn writeTrace(
832	831	t: Io.Terminal,
833	832	resolve_inline_callers: bool,
834	833	) Writer.Error!void {
	834	var text_arena: std.heap.ArenaAllocator = .init(getDebugInfoAllocator());
	835	defer text_arena.deinit();
	836
835	837	const writer = t.writer;
836	838	if (!std.options.allow_stack_tracing) {
837	839	t.setColor(.dim) catch {};
...	...	@@ -853,7 +855,7 @@ fn writeTrace(
853	855	for (addresses) \|addr\| {
854	856	// `addr` is the return address, which is after the function call.
855	857	// Subtract 1 to get an address in the function call for a better source location.
856		try printSourceAtAddress(io, di, t, .{
	858	try printSourceAtAddress(io, &text_arena, di, t, .{
857	859	.address = addr -\| StackIterator.ra_call_offset,
858	860	.resolve_inline_callers = resolve_inline_callers,
859	861	});
...	...	@@ -1186,21 +1188,28 @@ const PrintSourceAddressOptions = struct {
1186	1188
1187	1189	fn printSourceAtAddress(
1188	1190	io: Io,
	1191	text_arena: *std.heap.ArenaAllocator,
1189	1192	debug_info: *SelfInfo,
1190	1193	t: Io.Terminal,
1191	1194	options: PrintSourceAddressOptions,
1192	1195	) Writer.Error!void {
1193		// In the common case where there's only one symbol, allocate it on the stack. Reserve enough
1194		// space for one item regardless of alignment.
1195		var stack_fallback = std.heap.stackFallback(@sizeOf(Symbol) + @alignOf(Symbol) - 1, getDebugInfoAllocator());
1196		const sfa = stack_fallback.get();
1197		var symbols = std.ArrayList(Symbol).initCapacity(sfa, 1) catch unreachable;
1198		defer {
1199		for (symbols.items) \|*symbol\| symbol.deinit(sfa);
1200		symbols.deinit(sfa);
1201		}
1202
1203		debug_info.getSymbols(io, sfa, options.address, options.resolve_inline_callers, &symbols) catch \|err\| {
	1196	defer _ = text_arena.reset(.retain_capacity);
	1197
	1198	// Initialize the symbol array with space for at least one element, allocating this on the stack
	1199	// in the common case where only one element is needed
	1200	var symbol_fallback_allocator = std.heap.stackFallback(@sizeOf(Symbol) + @alignOf(Symbol) - 1, getDebugInfoAllocator());
	1201	const symbol_allocator = symbol_fallback_allocator.get();
	1202	var symbols = std.ArrayList(Symbol).initCapacity(symbol_allocator, 1) catch unreachable;
	1203	defer symbols.deinit(symbol_allocator);
	1204
	1205	debug_info.getSymbols(
	1206	io,
	1207	symbol_allocator,
	1208	text_arena.allocator(),
	1209	options.address,
	1210	options.resolve_inline_callers,
	1211	&symbols,
	1212	) catch \|err\| {
1204	1213	t.setColor(.dim) catch {};
1205	1214	defer t.setColor(.reset) catch {};
1206	1215	switch (err) {
...	...	@@ -1219,35 +1228,25 @@ fn printSourceAtAddress(
1219	1228	}
1220	1229	};
1221	1230
1222		// If we failed to get any symbols, append the unknown symbol. We initialized with a capacity of
1223		// one using a stack fallback allocator so this can't fail.
	1231	// If we failed to write any symbols, at least write the unknown symbol. Can't fail since we
	1232	// initialized with a capacity of 1.
1224	1233	if (symbols.items.len == 0) symbols.appendAssumeCapacity(.unknown);
1225	1234
1226	1235	for (symbols.items) \|symbol\| {
1227		try printLineInfo(
1228		io,
1229		t,
1230		debug_info,
1231		symbol.source_location,
1232		options.address,
1233		symbol.name,
1234		symbol.compile_unit_name,
1235		);
	1236	try printLineInfo(io, t, debug_info, options.address, symbol);
1236	1237	}
1237	1238	}
1238	1239	fn printLineInfo(
1239	1240	io: Io,
1240	1241	t: Io.Terminal,
1241	1242	debug_info: *SelfInfo,
1242		source_location: ?SourceLocation,
1243	1243	address: usize,
1244		symbol_name: ?[]const u8,
1245		compile_unit_name: ?[]const u8,
	1244	symbol: Symbol,
1246	1245	) Writer.Error!void {
1247	1246	const writer = t.writer;
1248	1247	t.setColor(.bold) catch {};
1249	1248
1250		if (source_location) \|*sl\| {
	1249	if (symbol.source_location) \|*sl\| {
1251	1250	if (sl.column == 0) {
1252	1251	try writer.print("{s}:{d}", .{ sl.file_name, sl.line });
1253	1252	} else {
...	...	@@ -1262,14 +1261,14 @@ fn printLineInfo(
1262	1261	t.setColor(.dim) catch {};
1263	1262	try writer.print("0x{x} in {s} ({s})", .{
1264	1263	address,
1265		symbol_name orelse "???",
1266		compile_unit_name orelse debug_info.getModuleName(io, address) catch "???",
	1264	symbol.name orelse "???",
	1265	symbol.compile_unit_name orelse debug_info.getModuleName(io, address) catch "???",
1267	1266	});
1268	1267	t.setColor(.reset) catch {};
1269	1268	try writer.writeAll("\n");
1270	1269
1271	1270	// Show the matching source code line if possible
1272		if (source_location) \|sl\| {
	1271	if (symbol.source_location) \|sl\| {
1273	1272	if (printLineFromFile(io, writer, sl)) {
1274	1273	if (sl.column > 0) {
1275	1274	// The caret already takes one char
...	...	@@ -1708,7 +1707,9 @@ test "manage resources correctly" {
1708	1707	var di: SelfInfo = .init;
1709	1708	defer di.deinit(io);
1710	1709	const t: Io.Terminal = .{ .writer = &discarding.writer, .mode = .no_color };
1711		try printSourceAtAddress(io, &di, t, .{
	1710	var text_arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
	1711	defer text_arena.deinit();
	1712	try printSourceAtAddress(io, &text_arena, &di, t, .{
1712	1713	.address = S.showMyTrace(),
1713	1714	.resolve_inline_callers = true,
1714	1715	});

lib/std/debug/Dwarf.zig+7-4

...	...	@@ -1220,6 +1220,7 @@ pub fn populateSrcLocCache(d: Dwarf, gpa: Allocator, endian: Endian, cu: Compi
1220	1220	pub fn getLineNumberInfo(
1221	1221	d: *Dwarf,
1222	1222	gpa: Allocator,
	1223	text_arena: Allocator,
1223	1224	endian: Endian,
1224	1225	compile_unit: *CompileUnit,
1225	1226	target_address: u64,
...	...	@@ -1232,7 +1233,7 @@ pub fn getLineNumberInfo(
1232	1233	const file_entry = &slc.files[file_index];
1233	1234	if (file_entry.dir_index >= slc.directories.len) return bad();
1234	1235	const dir_name = slc.directories[file_entry.dir_index].path;
1235		const file_name = try std.fs.path.join(gpa, &.{ dir_name, file_entry.path });
	1236	const file_name = try std.fs.path.join(text_arena, &.{ dir_name, file_entry.path });
1236	1237	return .{
1237	1238	.line = entry.line,
1238	1239	.column = entry.column,
...	...	@@ -1547,25 +1548,27 @@ fn getStringGeneric(opt_str: ?[]const u8, offset: u64) ![:0]const u8 {
1547	1548
1548	1549	pub fn getSymbols(
1549	1550	di: *Dwarf,
1550		gpa: Allocator,
	1551	symbol_allocator: Allocator,
	1552	text_arena: Allocator,
1551	1553	endian: Endian,
1552	1554	address: u64,
1553	1555	resolve_inline_callers: bool,
1554	1556	symbols: *std.ArrayList(std.debug.Symbol),
1555	1557	) std.debug.SelfInfoError!void {
1556	1558	_ = resolve_inline_callers;
	1559	const gpa = std.debug.getDebugInfoAllocator();
1557	1560
1558	1561	const compile_unit = di.findCompileUnit(endian, address) catch \|err\| switch (err) {
1559	1562	error.EndOfStream => return error.MissingDebugInfo,
1560	1563	error.Overflow => return error.InvalidDebugInfo,
1561	1564	error.ReadFailed, error.InvalidDebugInfo, error.MissingDebugInfo => \|e\| return e,
1562	1565	};
1563		try symbols.append(gpa, .{
	1566	try symbols.append(symbol_allocator, .{
1564	1567	.name = di.getSymbolName(address),
1565	1568	.compile_unit_name = compile_unit.die.getAttrString(di, endian, std.dwarf.AT.name, di.section(.debug_str), compile_unit) catch \|err\| switch (err) {
1566	1569	error.MissingDebugInfo, error.InvalidDebugInfo => null,
1567	1570	},
1568		.source_location = di.getLineNumberInfo(gpa, endian, compile_unit, address) catch \|err\| switch (err) {
	1571	.source_location = di.getLineNumberInfo(gpa, text_arena, endian, compile_unit, address) catch \|err\| switch (err) {
1569	1572	error.MissingDebugInfo, error.InvalidDebugInfo => null,
1570	1573	error.ReadFailed,
1571	1574	error.EndOfStream,

lib/std/debug/Pdb.zig+6-6

...	...	@@ -617,6 +617,7 @@ pub fn getBinaryAnnotations(self: Pdb, module: Module, site: *align(1) const p
617	617
618	618	pub fn getInlineSiteSourceLocation(
619	619	self: *Pdb,
	620	gpa: Allocator,
620	621	mod: *Module,
621	622	site: *align(1) const pdb.InlineSiteSym,
622	623	inlinee_src_line: *align(1) const pdb.InlineeSourceLine,
...	...	@@ -627,7 +628,7 @@ pub fn getInlineSiteSourceLocation(
627	628	if (!range.contains(offset_in_func)) continue;
628	629
629	630	const file_id = range.file_id orelse inlinee_src_line.file_id;
630		const file_name = try self.getFileName(mod, file_id);
	631	const file_name = try self.getFileName(gpa, mod, file_id);
631	632	errdefer self.allocator.free(file_name);
632	633
633	634	return .{
...	...	@@ -640,14 +641,14 @@ pub fn getInlineSiteSourceLocation(
640	641	return null;
641	642	}
642	643
643		pub fn getFileName(self: Pdb, mod: Module, file_id: u32) ![]const u8 {
	644	pub fn getFileName(self: Pdb, gpa: Allocator, mod: Module, file_id: u32) ![]const u8 {
644	645	const checksum_offset = mod.checksum_offset orelse return error.MissingDebugInfo;
645	646	const subsect_index = checksum_offset + file_id;
646	647	const chksum_hdr: *align(1) pdb.FileChecksumEntryHeader = @ptrCast(&mod.subsect_info[subsect_index]);
647	648	const strtab_offset = @sizeOf(pdb.StringTableHeader) + chksum_hdr.file_name_offset;
648	649	self.string_table.?.seekTo(strtab_offset) catch return error.InvalidDebugInfo;
649	650	const string_reader = &self.string_table.?.interface;
650		var source_file_name: Io.Writer.Allocating = .init(self.allocator);
	651	var source_file_name: Io.Writer.Allocating = .init(gpa);
651	652	defer source_file_name.deinit();
652	653	_ = try string_reader.streamDelimiterLimit(&source_file_name.writer, 0, .limited(1024));
653	654	assert(string_reader.buffered()[0] == 0); // TODO change streamDelimiterLimit API
...	...	@@ -716,10 +717,9 @@ pub fn getInlineeSourceLines(
716	717	return mod.inlinee_source_lines[begin..end];
717	718	}
718	719
719		pub fn getLineNumberInfo(self: Pdb, module: Module, address: u64) !std.debug.SourceLocation {
	720	pub fn getLineNumberInfo(self: Pdb, gpa: Allocator, module: Module, address: u64) !std.debug.SourceLocation {
720	721	std.debug.assert(module.populated);
721	722	const subsect_info = module.subsect_info;
722		const gpa = self.allocator;
723	723
724	724	var sect_offset: usize = 0;
725	725	var skip_len: usize = undefined;
...	...	@@ -769,7 +769,7 @@ pub fn getLineNumberInfo(self: Pdb, module: Module, address: u64) !std.debug.S
769	769
770	770	// line_i == 0 would mean that no matching pdb.LineNumberEntry was found.
771	771	if (line_i > 0) {
772		const file_name = try self.getFileName(module, block_hdr.name_index);
	772	const file_name = try self.getFileName(gpa, module, block_hdr.name_index);
773	773	errdefer gpa.free(file_name);
774	774
775	775	const line_entry_idx = line_i - 1;

lib/std/debug/SelfInfo/Elf.zig+12-3

...	...	@@ -33,11 +33,13 @@ pub fn deinit(si: *SelfInfo, io: Io) void {
33	33	pub fn getSymbols(
34	34	si: *SelfInfo,
35	35	io: Io,
36		gpa: Allocator,
	36	symbol_allocator: Allocator,
	37	text_arena: Allocator,
37	38	address: usize,
38	39	resolve_inline_callers: bool,
39	40	symbols: *std.ArrayList(std.debug.Symbol),
40	41	) Error!void {
	42	const gpa = std.debug.getDebugInfoAllocator();
41	43	const module = try si.findModule(gpa, io, address, .exclusive);
42	44	defer si.rwlock.unlock(io);
43	45
...	...	@@ -59,10 +61,17 @@ pub fn getSymbols(
59	61	};
60	62	loaded_elf.scanned_dwarf = true;
61	63	}
62		return dwarf.getSymbols(gpa, native_endian, vaddr, resolve_inline_callers, symbols);
	64	return dwarf.getSymbols(
	65	symbol_allocator,
	66	text_arena,
	67	native_endian,
	68	vaddr,
	69	resolve_inline_callers,
	70	symbols,
	71	);
63	72	}
64	73	// When DWARF is unavailable, fall back to searching the symtab.
65		try symbols.append(gpa, loaded_elf.file.searchSymtab(gpa, vaddr) catch \|err\| switch (err) {
	74	try symbols.append(symbol_allocator, loaded_elf.file.searchSymtab(gpa, vaddr) catch \|err\| switch (err) {
66	75	error.NoSymtab, error.NoStrtab => return error.MissingDebugInfo,
67	76	error.BadSymtab => return error.InvalidDebugInfo,
68	77	error.OutOfMemory => \|e\| return e,

lib/std/debug/SelfInfo/MachO.zig+7-4

...	...	@@ -25,12 +25,14 @@ pub fn deinit(si: *SelfInfo, io: Io) void {
25	25	pub fn getSymbols(
26	26	si: *SelfInfo,
27	27	io: Io,
28		gpa: Allocator,
	28	symbol_allocator: Allocator,
	29	text_arena: Allocator,
29	30	address: usize,
30	31	resolve_inline_callers: bool,
31	32	symbols: *std.ArrayList(std.debug.Symbol),
32	33	) Error!void {
33	34	_ = resolve_inline_callers;
	35	const gpa = std.debug.getDebugInfoAllocator();
34	36
35	37	const module = try si.findModule(gpa, io, address);
36	38	defer si.mutex.unlock(io);
...	...	@@ -51,7 +53,7 @@ pub fn getSymbols(
51	53
52	54	const ofile_dwarf, const ofile_vaddr = file.getDwarfForAddress(gpa, io, vaddr) catch {
53	55	// Return at least the symbol name if available.
54		return symbols.append(gpa, .{
	56	return symbols.append(symbol_allocator, .{
55	57	.name = try file.lookupSymbolName(vaddr),
56	58	.compile_unit_name = null,
57	59	.source_location = null,
...	...	@@ -60,14 +62,14 @@ pub fn getSymbols(
60	62
61	63	const compile_unit = ofile_dwarf.findCompileUnit(native_endian, ofile_vaddr) catch {
62	64	// Return at least the symbol name if available.
63		return symbols.append(gpa, .{
	65	return symbols.append(symbol_allocator, .{
64	66	.name = try file.lookupSymbolName(vaddr),
65	67	.compile_unit_name = null,
66	68	.source_location = null,
67	69	});
68	70	};
69	71
70		try symbols.append(gpa, .{
	72	try symbols.append(symbol_allocator, .{
71	73	.name = ofile_dwarf.getSymbolName(ofile_vaddr) orelse
72	74	try file.lookupSymbolName(vaddr),
73	75	.compile_unit_name = compile_unit.die.getAttrString(
...	...	@@ -81,6 +83,7 @@ pub fn getSymbols(
81	83	},
82	84	.source_location = ofile_dwarf.getLineNumberInfo(
83	85	gpa,
	86	text_arena,
84	87	native_endian,
85	88	compile_unit,
86	89	ofile_vaddr,

lib/std/debug/SelfInfo/Windows.zig+19-7

...	...	@@ -28,17 +28,20 @@ pub fn deinit(si: *SelfInfo, io: Io) void {
28	28	pub fn getSymbols(
29	29	si: *SelfInfo,
30	30	io: Io,
31		gpa: Allocator,
	31	symbol_allocator: Allocator,
	32	text_arena: Allocator,
32	33	address: usize,
33	34	resolve_inline_callers: bool,
34	35	symbols: *std.ArrayList(std.debug.Symbol),
35	36	) Error!void {
	37	const gpa = std.debug.getDebugInfoAllocator();
36	38	try si.lock.lockShared(io);
37	39	defer si.lock.unlockShared(io);
38	40	const module = try si.findModule(gpa, address);
39	41	const di = try module.getDebugInfo(gpa, io);
40	42	return di.getSymbols(
41		gpa,
	43	symbol_allocator,
	44	text_arena,
42	45	address - @intFromPtr(module.entry.DllBase),
43	46	resolve_inline_callers,
44	47	symbols,
...	...	@@ -254,7 +257,8 @@ const Module = struct {
254	257
255	258	fn getSymbols(
256	259	di: *DebugInfo,
257		gpa: Allocator,
	260	symbol_allocator: Allocator,
	261	text_arena: Allocator,
258	262	vaddr: usize,
259	263	resolve_inline_callers: bool,
260	264	symbols: *std.ArrayList(std.debug.Symbol),
...	...	@@ -312,6 +316,7 @@ const Module = struct {
312	316	inline_site.inlinee,
313	317	)) \|inlinee_src_line\| {
314	318	const maybe_loc = pdb.getInlineSiteSourceLocation(
	319	text_arena,
315	320	module,
316	321	inline_site,
317	322	inlinee_src_line.info,
...	...	@@ -333,7 +338,7 @@ const Module = struct {
333	338	else
334	339	null;
335	340
336		try symbols.append(gpa, .{
	341	try symbols.append(symbol_allocator, .{
337	342	.name = name,
338	343	.compile_unit_name = compile_unit_name,
339	344	.source_location = loc,
...	...	@@ -359,10 +364,10 @@ const Module = struct {
359	364
360	365	// If there's room for another symbol, add the actual proc
361	366	if (resolve_inline_callers or symbols.items.len == 0) {
362		try symbols.append(gpa, .{
	367	try symbols.append(symbol_allocator, .{
363	368	.name = if (maybe_proc) \|proc\| pdb.getSymbolName(proc) else null,
364	369	.compile_unit_name = compile_unit_name,
365		.source_location = pdb.getLineNumberInfo(module, addr) catch null,
	370	.source_location = pdb.getLineNumberInfo(text_arena, module, addr) catch null,
366	371	});
367	372	}
368	373
...	...	@@ -372,7 +377,14 @@ const Module = struct {
372	377	dwarf: {
373	378	const dwarf = &(di.dwarf orelse break :dwarf);
374	379	const addr = vaddr + di.coff_image_base;
375		return dwarf.getSymbols(gpa, native_endian, addr, resolve_inline_callers, symbols);
	380	return dwarf.getSymbols(
	381	symbol_allocator,
	382	text_arena,
	383	native_endian,
	384	addr,
	385	resolve_inline_callers,
	386	symbols,
	387	);
376	388	}
377	389
378	390	return error.MissingDebugInfo;

test/standalone/coff_dwarf/main.zig+19-9

...	...	@@ -12,16 +12,26 @@ pub fn main(init: std.process.Init) void {
12	12	var add_addr: usize = undefined;
13	13	_ = add(1, 2, &add_addr);
14	14
15		const symbols = di.getSymbols(io, add_addr, false) catch \|err\| fatal("failed to get symbol: {t}", .{err});
16	15	const debug_gpa = std.debug.getDebugInfoAllocator();
17		defer for (symbols) \|symbol\| {
18		if (symbol.source_location) \|sl\| {
19		debug_gpa.free(sl.file_name);
20		}
21		};
22
23		if (symbols.len != 1) fatal("expected 1 symbol, found {}", .{symbols.len});
24		const symbol = symbols[0];
	16	const symbol_allocator = debug_gpa;
	17
	18	var symbols: std.ArrayList(std.debug.Symbol) = .empty;
	19	defer symbols.deinit(symbol_allocator);
	20
	21	var text_arena: std.heap.ArenaAllocator = .init(debug_gpa);
	22	defer text_arena.deinit();
	23
	24	di.getSymbols(
	25	io,
	26	symbol_allocator,
	27	text_arena.allocator(),
	28	add_addr,
	29	false,
	30	&symbols,
	31	) catch \|err\| fatal("failed to get symbol: {t}", .{err});
	32
	33	if (symbols.items.len != 1) fatal("expected 1 symbol, found {}", .{symbols.items.len});
	34	const symbol = symbols.items[0];
25	35
26	36	if (symbol.name == null) fatal("failed to resolve symbol name", .{});
27	37	if (symbol.compile_unit_name == null) fatal("failed to resolve compile unit", .{});

author	Mason Remaley <mason@gamesbymason.com> 2026-04-13 00:43:34-07:00
committer	Mason Remaley <mason@gamesbymason.com> 2026-04-13 01:30:14-07:00
log	6707a5efeea1ab973c3274495bb0a5640e4f568b
tree	e3f815ac7949a0b33ad997e386ccb4cdd5a81bcc
parent	4ad665d3c8cd6a9d4f6b0e2f065098436142b450

Arena allocates text