Commit f56ae69edd8c96a5f6525f20bf0a22704a826f00 | zig

author	Luuk de Gram <luuk@degram.dev> 2021-11-24 19:09:37+01:00
committer	Luuk de Gram <luuk@degram.dev> 2021-11-27 15:02:01+01:00
log	f56ae69edd8c96a5f6525f20bf0a22704a826f00
tree	84778ce7a9eba390227e043e99fb6663e940f946
parent	17f057c5568bda6b011a213c95aa9538f6fb6a78
signature	Commit is signed but in an unrecognized format.

wasm-linker: Upstream zwld into stage2

- Converts previous `DeclBlock` into `Atom`'s to also make them compatible when
the rest of zlwd gets upstreamed and we can link with other object files.
- Resolves function signatures and removes any duplicates, saving us a lot of
potential bytes for larger projects.
- We now create symbols for each decl of the respective type
- We can now (but not implemented yet) perform proper relocations.
- Having symbols and segment_info allows us to create an object file
for wasm.

7 files changed, 1085 insertions(+), 339 deletions(-)

lib
- std
  - wasm.zig
src
- arch
  - wasm
    CodeGen.zig
    Emit.zig
- link
  - Wasm.zig
  - Wasm
    Atom.zig
    Symbol.zig
    types.zig

lib/std/wasm.zig+139-3

...	...	@@ -1,4 +1,8 @@
1		const testing = @import("std.zig").testing;
	1	///! Contains all constants and types representing the wasm
	2	///! binary format, as specified by:
	3	///! https://webassembly.github.io/spec/core/
	4	const std = @import("std.zig");
	5	const testing = std.testing;
2	6
3	7	// TODO: Add support for multi-byte ops (e.g. table operations)
4	8
...	...	@@ -222,6 +226,18 @@ pub fn valtype(value: Valtype) u8 {
222	226	return @enumToInt(value);
223	227	}
224	228
	229	/// Reference types, where the funcref references to a function regardless of its type
	230	/// and ref references an object from the embedder.
	231	pub const RefType = enum(u8) {
	232	funcref = 0x70,
	233	externref = 0x6F,
	234	};
	235
	236	/// Returns the integer value of a `Reftype`
	237	pub fn reftype(value: RefType) u8 {
	238	return @enumToInt(value);
	239	}
	240
225	241	test "Wasm - valtypes" {
226	242	const _i32 = valtype(.i32);
227	243	const _i64 = valtype(.i64);
...	...	@@ -234,6 +250,124 @@ test "Wasm - valtypes" {
234	250	try testing.expectEqual(@as(u8, 0x7C), _f64);
235	251	}
236	252
	253	/// Limits classify the size range of resizeable storage associated with memory types and table types.
	254	pub const Limits = struct {
	255	min: u32,
	256	max: ?u32,
	257	};
	258
	259	/// Initialization expressions are used to set the initial value on an object
	260	/// when a wasm module is being loaded.
	261	pub const InitExpression = union(enum) {
	262	i32_const: i32,
	263	i64_const: i64,
	264	f32_const: f32,
	265	f64_const: f64,
	266	global_get: u32,
	267	};
	268
	269	///
	270	pub const Func = struct {
	271	type_index: u32,
	272	};
	273
	274	/// Tables are used to hold pointers to opaque objects.
	275	/// This can either by any function, or an object from the host.
	276	pub const Table = struct {
	277	limits: Limits,
	278	reftype: RefType,
	279	};
	280
	281	/// Describes the layout of the memory where `min` represents
	282	/// the minimal amount of pages, and the optional `max` represents
	283	/// the max pages. When `null` will allow the host to determine the
	284	/// amount of pages.
	285	pub const Memory = struct {
	286	limits: Limits,
	287	};
	288
	289	/// Represents the type of a `Global` or an imported global.
	290	pub const GlobalType = struct {
	291	valtype: Valtype,
	292	mutable: bool,
	293	};
	294
	295	pub const Global = struct {
	296	global_type: GlobalType,
	297	init: InitExpression,
	298	};
	299
	300	/// Notates an object to be exported from wasm
	301	/// to the host.
	302	pub const Export = struct {
	303	name: []const u8,
	304	kind: ExternalKind,
	305	index: u32,
	306	};
	307
	308	/// Element describes the layout of the table that can
	309	/// be found at `table_index`
	310	pub const Element = struct {
	311	table_index: u32,
	312	offset: InitExpression,
	313	func_indexes: []const u32,
	314	};
	315
	316	/// Imports are used to import objects from the host
	317	pub const Import = struct {
	318	module_name: []const u8,
	319	name: []const u8,
	320	kind: Kind,
	321
	322	pub const Kind = union(ExternalKind) {
	323	function: u32,
	324	table: Table,
	325	memory: Limits,
	326	global: GlobalType,
	327	};
	328	};
	329
	330	/// `Type` represents a function signature type containing both
	331	/// a slice of parameters as well as a slice of return values.
	332	pub const Type = struct {
	333	params: []const Valtype,
	334	returns: []const Valtype,
	335
	336	pub fn format(self: Type, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
	337	_ = fmt;
	338	_ = opt;
	339	try writer.writeByte('(');
	340	for (self.params) \|param, i\| {
	341	try writer.print("{s}", .{@tagName(param)});
	342	if (i + 1 != self.params.len) {
	343	try writer.writeAll(", ");
	344	}
	345	}
	346	try writer.writeAll(") -> ");
	347	if (self.returns.len == 0) {
	348	try writer.writeAll("nil");
	349	} else {
	350	for (self.returns) \|return_ty, i\| {
	351	try writer.print("{s}", .{@tagName(return_ty)});
	352	if (i + 1 != self.returns.len) {
	353	try writer.writeAll(", ");
	354	}
	355	}
	356	}
	357	}
	358
	359	pub fn eql(self: Type, other: Type) bool {
	360	return std.mem.eql(Valtype, self.params, other.params) and
	361	std.mem.eql(Valtype, self.returns, other.returns);
	362	}
	363
	364	pub fn deinit(self: Type, gpa: std.mem.Allocator) void {
	365	gpa.free(self.params);
	366	gpa.free(self.returns);
	367	self.* = undefined;
	368	}
	369	};
	370
237	371	/// Wasm module sections as per spec:
238	372	/// https://webassembly.github.io/spec/core/binary/modules.html
239	373	pub const Section = enum(u8) {
...	...	@@ -249,6 +383,8 @@ pub const Section = enum(u8) {
249	383	element,
250	384	code,
251	385	data,
	386	data_count,
	387	_,
252	388	};
253	389
254	390	/// Returns the integer value of a given `Section`
...	...	@@ -270,7 +406,7 @@ pub fn externalKind(val: ExternalKind) u8 {
270	406	return @enumToInt(val);
271	407	}
272	408
273		// types
	409	// type constants
274	410	pub const element_type: u8 = 0x70;
275	411	pub const function_type: u8 = 0x60;
276	412	pub const result_type: u8 = 0x40;
...	...	@@ -280,7 +416,7 @@ pub const block_empty: u8 = 0x40;
280	416
281	417	// binary constants
282	418	pub const magic = [_]u8{ 0x00, 0x61, 0x73, 0x6D }; // \0asm
283		pub const version = [_]u8{ 0x01, 0x00, 0x00, 0x00 }; // version 1
	419	pub const version = [_]u8{ 0x01, 0x00, 0x00, 0x00 }; // version 1 (MVP)
284	420
285	421	// Each wasm page size is 64kB
286	422	pub const page_size = 64 * 1024;

src/arch/wasm/CodeGen.zig+35-33

...	...	@@ -518,9 +518,6 @@ blocks: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, struct {
518	518	}) = .{},
519	519	/// `bytes` contains the wasm bytecode belonging to the 'code' section.
520	520	code: ArrayList(u8),
521		/// Contains the generated function type bytecode for the current function
522		/// found in `decl`
523		func_type_data: ArrayList(u8),
524	521	/// The index the next local generated will have
525	522	/// NOTE: arguments share the index with locals therefore the first variable
526	523	/// will have the index that comes after the last argument's index
...	...	@@ -539,7 +536,7 @@ locals: std.ArrayListUnmanaged(u8),
539	536	/// The Target we're emitting (used to call intInfo)
540	537	target: std.Target,
541	538	/// Represents the wasm binary file that is being linked.
542		bin_file: *link.File,
	539	bin_file: *link.File.Wasm,
543	540	/// Table with the global error set. Consists of every error found in
544	541	/// the compiled code. Each error name maps to a `Module.ErrorInt` which is emitted
545	542	/// during codegen to determine the error value.
...	...	@@ -577,6 +574,7 @@ pub fn deinit(self: *Self) void {
577	574	self.locals.deinit(self.gpa);
578	575	self.mir_instructions.deinit(self.gpa);
579	576	self.mir_extra.deinit(self.gpa);
	577	self.code.deinit();
580	578	self.* = undefined;
581	579	}
582	580
...	...	@@ -734,43 +732,44 @@ fn allocLocal(self: *Self, ty: Type) InnerError!WValue {
734	732	return WValue{ .local = initial_index };
735	733	}
736	734
737		fn genFunctype(self: *Self) InnerError!void {
738		assert(self.decl.has_tv);
739		const ty = self.decl.ty;
740		const writer = self.func_type_data.writer();
741
742		try writer.writeByte(wasm.function_type);
	735	/// Generates a `wasm.Type` from a given function type.
	736	/// Memory is owned by the caller.
	737	fn genFunctype(self: *Self, fn_ty: Type) !wasm.Type {
	738	var params = std.ArrayList(wasm.Valtype).init(self.gpa);
	739	defer params.deinit();
	740	var returns = std.ArrayList(wasm.Valtype).init(self.gpa);
	741	defer returns.deinit();
743	742
744	743	// param types
745		try leb.writeULEB128(writer, @intCast(u32, ty.fnParamLen()));
746		if (ty.fnParamLen() != 0) {
747		const params = try self.gpa.alloc(Type, ty.fnParamLen());
748		defer self.gpa.free(params);
749		ty.fnParamTypes(params);
750		for (params) \|param_type\| {
751		// Can we maybe get the source index of each param?
752		const val_type = try self.genValtype(param_type);
753		try writer.writeByte(val_type);
	744	if (fn_ty.fnParamLen() != 0) {
	745	const fn_params = try self.gpa.alloc(Type, fn_ty.fnParamLen());
	746	defer self.gpa.free(fn_params);
	747	fn_ty.fnParamTypes(fn_params);
	748	for (fn_params) \|param_type\| {
	749	if (!param_type.hasCodeGenBits()) continue;
	750	try params.append(try self.typeToValtype(param_type));
754	751	}
755	752	}
756	753
757	754	// return type
758		const return_type = ty.fnReturnType();
	755	const return_type = fn_ty.fnReturnType();
759	756	switch (return_type.zigTypeTag()) {
760		.Void, .NoReturn => try leb.writeULEB128(writer, @as(u32, 0)),
	757	.Void, .NoReturn => {},
761	758	.Struct => return self.fail("TODO: Implement struct as return type for wasm", .{}),
762	759	.Optional => return self.fail("TODO: Implement optionals as return type for wasm", .{}),
763		else => {
764		try leb.writeULEB128(writer, @as(u32, 1));
765		const val_type = try self.genValtype(return_type);
766		try writer.writeByte(val_type);
767		},
	760	else => try returns.append(try self.typeToValtype(return_type)),
768	761	}
	762
	763	return wasm.Type{
	764	.params = params.toOwnedSlice(),
	765	.returns = returns.toOwnedSlice(),
	766	};
769	767	}
770	768
771	769	pub fn genFunc(self: *Self) InnerError!Result {
772		try self.genFunctype();
773		// TODO: check for and handle death of instructions
	770	var func_type = try self.genFunctype(self.decl.ty);
	771	defer func_type.deinit(self.gpa);
	772	self.decl.fn_link.wasm.type_index = try self.bin_file.putOrGetFuncType(func_type);
774	773
775	774	var cc_result = try self.resolveCallingConventionValues(self.decl.ty);
776	775	defer cc_result.deinit(self.gpa);
...	...	@@ -791,7 +790,7 @@ pub fn genFunc(self: *Self) InnerError!Result {
791	790
792	791	var emit: Emit = .{
793	792	.mir = mir,
794		.bin_file = self.bin_file,
	793	.bin_file = &self.bin_file.base,
795	794	.code = &self.code,
796	795	.locals = self.locals.items,
797	796	.decl = self.decl,
...	...	@@ -813,8 +812,10 @@ pub fn genFunc(self: *Self) InnerError!Result {
813	812	pub fn gen(self: *Self, ty: Type, val: Value) InnerError!Result {
814	813	switch (ty.zigTypeTag()) {
815	814	.Fn => {
816		try self.genFunctype();
817	815	if (val.tag() == .extern_fn) {
	816	var func_type = try self.genFunctype(self.decl.ty);
	817	defer func_type.deinit(self.gpa);
	818	self.decl.fn_link.wasm.type_index = try self.bin_file.putOrGetFuncType(func_type);
818	819	return Result.appended; // don't need code body for extern functions
819	820	}
820	821	return self.fail("TODO implement wasm codegen for function pointers", .{});
...	...	@@ -1079,7 +1080,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
1079	1080	try self.emitWValue(arg_val);
1080	1081	}
1081	1082
1082		try self.addLabel(.call, target.link.wasm.symbol_index);
	1083	try self.addLabel(.call, target.link.wasm.sym_index);
1083	1084
1084	1085	const ret_ty = target.ty.fnReturnType();
1085	1086	switch (ret_ty.zigTypeTag()) {
...	...	@@ -1364,13 +1365,14 @@ fn emitConstant(self: *Self, val: Value, ty: Type) InnerError!void {
1364	1365	decl.alive = true;
1365	1366
1366	1367	// offset into the offset table within the 'data' section
1367		const ptr_width = self.target.cpu.arch.ptrBitWidth() / 8;
1368		try self.addImm32(@bitCast(i32, decl.link.wasm.offset_index * ptr_width));
	1368	// const ptr_width = self.target.cpu.arch.ptrBitWidth() / 8;
	1369	// try self.addImm32(@bitCast(i32, decl.link.wasm.offset_index * ptr_width));
1369	1370
1370	1371	// memory instruction followed by their memarg immediate
1371	1372	// memarg ::== x:u32, y:u32 => {align x, offset y}
1372	1373	const extra_index = try self.addExtra(Mir.MemArg{ .offset = 0, .alignment = 4 });
1373	1374	try self.addInst(.{ .tag = .i32_load, .data = .{ .payload = extra_index } });
	1375	@panic("REDO!\n");
1374	1376	} else return self.fail("Wasm TODO: emitConstant for other const pointer tag {s}", .{val.tag()});
1375	1377	},
1376	1378	.Void => {},

src/arch/wasm/Emit.zig+3-9

...	...	@@ -29,8 +29,6 @@ const InnerError = error{
29	29
30	30	pub fn emitMir(emit: *Emit) InnerError!void {
31	31	const mir_tags = emit.mir.instructions.items(.tag);
32		// Reserve space to write the size after generating the code.
33		try emit.code.resize(5);
34	32	// write the locals in the prologue of the function body
35	33	// before we emit the function body when lowering MIR
36	34	try emit.emitLocals();
...	...	@@ -157,11 +155,6 @@ pub fn emitMir(emit: *Emit) InnerError!void {
157	155	.i64_extend32_s => try emit.emitTag(tag),
158	156	}
159	157	}
160
161		// Fill in the size of the generated code to the reserved space at the
162		// beginning of the buffer.
163		const size = emit.code.items.len - 5;
164		leb128.writeUnsignedFixed(5, emit.code.items[0..5], @intCast(u32, size));
165	158	}
166	159
167	160	fn fail(emit: *Emit, comptime format: []const u8, args: anytype) InnerError {
...	...	@@ -269,8 +262,9 @@ fn emitCall(emit: *Emit, inst: Mir.Inst.Index) !void {
269	262	// The function index immediate argument will be filled in using this data
270	263	// in link.Wasm.flush().
271	264	// TODO: Replace this with proper relocations saved in the Atom.
272		try emit.decl.fn_link.wasm.idx_refs.append(emit.bin_file.allocator, .{
	265	try emit.decl.link.wasm.relocs.append(emit.bin_file.allocator, .{
273	266	.offset = offset,
274		.decl = label,
	267	.index = label,
	268	.relocation_type = .R_WASM_FUNCTION_INDEX_LEB,
275	269	});
276	270	}

src/link/Wasm.zig+370-294

...	...	@@ -10,6 +10,7 @@ const leb = std.leb;
10	10	const log = std.log.scoped(.link);
11	11	const wasm = std.wasm;
12	12
	13	const Atom = @import("Wasm/Atom.zig");
13	14	const Module = @import("../Module.zig");
14	15	const Compilation = @import("../Compilation.zig");
15	16	const CodeGen = @import("../arch/wasm/CodeGen.zig");
...	...	@@ -22,101 +23,80 @@ const TypedValue = @import("../TypedValue.zig");
22	23	const LlvmObject = @import("../codegen/llvm.zig").Object;
23	24	const Air = @import("../Air.zig");
24	25	const Liveness = @import("../Liveness.zig");
	26	const Symbol = @import("Wasm/Symbol.zig");
	27	const types = @import("Wasm/types.zig");
25	28
26	29	pub const base_tag = link.File.Tag.wasm;
27	30
	31	/// deprecated: Use `@import("Wasm/Atom.zig");`
	32	pub const DeclBlock = Atom;
	33
28	34	base: link.File,
29	35	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
30	36	llvm_object: ?*LlvmObject = null,
31		/// List of all function Decls to be written to the output file. The index of
32		/// each Decl in this list at the time of writing the binary is used as the
33		/// function index. In the event where ext_funcs' size is not 0, the index of
34		/// each function is added on top of the ext_funcs' length.
35		/// TODO: can/should we access some data structure in Module directly?
36		funcs: std.ArrayListUnmanaged(*Module.Decl) = .{},
37		/// List of all extern function Decls to be written to the `import` section of the
38		/// wasm binary. The position in the list defines the function index
39		ext_funcs: std.ArrayListUnmanaged(*Module.Decl) = .{},
40	37	/// When importing objects from the host environment, a name must be supplied.
41	38	/// LLVM uses "env" by default when none is given. This would be a good default for Zig
42	39	/// to support existing code.
43	40	/// TODO: Allow setting this through a flag?
44	41	host_name: []const u8 = "env",
45	42	/// The last `DeclBlock` that was initialized will be saved here.
46		last_block: ?*DeclBlock = null,
47		/// Table with offsets, each element represents an offset with the value being
48		/// the offset into the 'data' section where the data lives
49		offset_table: std.ArrayListUnmanaged(u32) = .{},
50		/// List of offset indexes which are free to be used for new decl's.
51		/// Each element's value points to an index into the offset_table.
52		offset_table_free_list: std.ArrayListUnmanaged(u32) = .{},
	43	last_atom: ?*Atom = null,
53	44	/// List of all `Decl` that are currently alive.
54	45	/// This is ment for bookkeeping so we can safely cleanup all codegen memory
55	46	/// when calling `deinit`
56		symbols: std.ArrayListUnmanaged(*Module.Decl) = .{},
	47	decls: std.AutoHashMapUnmanaged(*Module.Decl, void) = .{},
	48	/// List of all symbols.
	49	symbols: std.ArrayListUnmanaged(Symbol) = .{},
57	50	/// List of symbol indexes which are free to be used.
58	51	symbols_free_list: std.ArrayListUnmanaged(u32) = .{},
	52	/// Maps atoms to their segment index
	53	atoms: std.AutoHashMapUnmanaged(u32, *Atom) = .{},
	54	/// Represents the index into `segments` where the 'code' section
	55	/// lives.
	56	code_section_index: ?u32 = null,
	57	/// The count of imported functions. This number will be appended
	58	/// to the function indexes as their index starts at the lowest non-extern function.
	59	imported_functions_count: u32 = 0,
	60	/// List of all 'extern' declarations
	61	imports: std.ArrayListUnmanaged(wasm.Import) = .{},
	62	/// List of indexes of symbols representing extern declarations.
	63	import_symbols: std.ArrayListUnmanaged(u32) = .{},
	64	/// Represents non-synthetic section entries.
	65	/// Used for code, data and custom sections.
	66	segments: std.ArrayListUnmanaged(Segment) = .{},
	67	/// Maps a data segment key (such as .rodata) to the index into `segments`.
	68	data_segments: std.StringArrayHashMapUnmanaged(u32) = .{},
	69	/// A list of `types.Segment` which provide meta data
	70	/// about a data symbol such as its name
	71	segment_info: std.ArrayListUnmanaged(types.Segment) = .{},
	72
	73	// Output sections
	74	/// Output type section
	75	func_types: std.ArrayListUnmanaged(wasm.Type) = .{},
	76	/// Output function section
	77	functions: std.ArrayListUnmanaged(wasm.Func) = .{},
	78	/// Output global section
	79	globals: std.ArrayListUnmanaged(wasm.Global) = .{},
	80
	81	/// Indirect function table, used to call function pointers
	82	/// When this is non-zero, we must emit a table entry,
	83	/// as well as an 'elements' section.
	84	function_table: std.ArrayListUnmanaged(Symbol) = .{},
	85
	86	pub const Segment = struct {
	87	alignment: u32,
	88	size: u32,
	89	offset: u32,
	90	};
59	91
60	92	pub const FnData = struct {
61		/// Generated code for the type of the function
62		functype: std.ArrayListUnmanaged(u8),
63		/// Generated code for the body of the function
64		code: std.ArrayListUnmanaged(u8),
65		/// Locations in the generated code where function indexes must be filled in.
66		/// This must be kept ordered by offset.
67		/// `decl` is the symbol_index of the target.
68		idx_refs: std.ArrayListUnmanaged(struct { offset: u32, decl: u32 }),
	93	type_index: u32,
69	94
70	95	pub const empty: FnData = .{
71		.functype = .{},
72		.code = .{},
73		.idx_refs = .{},
	96	.type_index = undefined,
74	97	};
75	98	};
76	99
77		pub const DeclBlock = struct {
78		/// Determines whether the `DeclBlock` has been initialized for codegen.
79		init: bool,
80		/// Index into the `symbols` list.
81		symbol_index: u32,
82		/// Index into the offset table
83		offset_index: u32,
84		/// The size of the block and how large part of the data section it occupies.
85		/// Will be 0 when the Decl will not live inside the data section and `data` will be undefined.
86		size: u32,
87		/// Points to the previous and next blocks.
88		/// Can be used to find the total size, and used to calculate the `offset` based on the previous block.
89		prev: ?*DeclBlock,
90		next: ?*DeclBlock,
91		/// Pointer to data that will be written to the 'data' section.
92		/// This data either lives in `FnData.code` or is externally managed.
93		/// For data that does not live inside the 'data' section, this field will be undefined. (size == 0).
94		data: [*]const u8,
95
96		pub const empty: DeclBlock = .{
97		.init = false,
98		.symbol_index = 0,
99		.offset_index = 0,
100		.size = 0,
101		.prev = null,
102		.next = null,
103		.data = undefined,
104		};
105
106		/// Unplugs the `DeclBlock` from the chain
107		fn unplug(self: *DeclBlock) void {
108		if (self.prev) \|prev\| {
109		prev.next = self.next;
110		}
111
112		if (self.next) \|next\| {
113		next.prev = self.prev;
114		}
115		self.next = null;
116		self.prev = null;
117		}
118		};
119
120	100	pub fn openPath(allocator: Allocator, sub_path: []const u8, options: link.Options) !Wasm {
121	101	assert(options.object_format == .wasm);
122	102
...	...	@@ -139,6 +119,22 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
139	119
140	120	try file.writeAll(&(wasm.magic ++ wasm.version));
141	121
	122	// As sym_index '0' is reserved, we use it for our stack pointer symbol
	123	const global = try wasm_bin.globals.addOne(allocator);
	124	global.* = .{
	125	.global_type = .{
	126	.valtype = .i32,
	127	.mutable = true,
	128	},
	129	.init = .{ .i32_const = 0 },
	130	};
	131	const symbol = try wasm_bin.symbols.addOne(allocator);
	132	symbol.* = .{
	133	.name = "__stack_pointer",
	134	.tag = .global,
	135	.flags = 0,
	136	.index = 0,
	137	};
142	138	return wasm_bin;
143	139	}
144	140
...	...	@@ -160,63 +156,58 @@ pub fn deinit(self: *Wasm) void {
160	156	if (self.llvm_object) \|llvm_object\| llvm_object.destroy(self.base.allocator);
161	157	}
162	158
163		for (self.symbols.items) \|decl, symbol_index\| {
164		// Check if we already freed all memory for the symbol
165		// TODO: Audit this when we refactor the linker.
166		var already_freed = false;
167		for (self.symbols_free_list.items) \|index\| {
168		if (symbol_index == index) {
169		already_freed = true;
170		break;
171		}
172		}
173		if (already_freed) continue;
174		decl.fn_link.wasm.functype.deinit(self.base.allocator);
175		decl.fn_link.wasm.code.deinit(self.base.allocator);
176		decl.fn_link.wasm.idx_refs.deinit(self.base.allocator);
	159	var decl_it = self.decls.keyIterator();
	160	while (decl_it.next()) \|decl_ptr\| {
	161	const decl = decl_ptr.*;
	162	decl.link.wasm.deinit(self.base.allocator);
	163	}
	164
	165	for (self.func_types.items) \|func_type\| {
	166	self.base.allocator.free(func_type.params);
	167	self.base.allocator.free(func_type.returns);
	168	}
	169	for (self.segment_info.items) \|segment_info\| {
	170	self.base.allocator.free(segment_info.name);
177	171	}
178	172
179		self.funcs.deinit(self.base.allocator);
180		self.ext_funcs.deinit(self.base.allocator);
181		self.offset_table.deinit(self.base.allocator);
182		self.offset_table_free_list.deinit(self.base.allocator);
	173	self.decls.deinit(self.base.allocator);
183	174	self.symbols.deinit(self.base.allocator);
184	175	self.symbols_free_list.deinit(self.base.allocator);
	176	self.atoms.deinit(self.base.allocator);
	177	self.segments.deinit(self.base.allocator);
	178	self.data_segments.deinit(self.base.allocator);
	179	self.segment_info.deinit(self.base.allocator);
	180
	181	// free output sections
	182	self.imports.deinit(self.base.allocator);
	183	self.import_symbols.deinit(self.base.allocator);
	184	self.func_types.deinit(self.base.allocator);
	185	self.functions.deinit(self.base.allocator);
	186	self.globals.deinit(self.base.allocator);
	187	self.function_table.deinit(self.base.allocator);
185	188	}
186	189
187	190	pub fn allocateDeclIndexes(self: Wasm, decl: Module.Decl) !void {
188		if (decl.link.wasm.init) return;
	191	if (decl.link.wasm.sym_index != 0) return;
189	192
190		try self.offset_table.ensureUnusedCapacity(self.base.allocator, 1);
191	193	try self.symbols.ensureUnusedCapacity(self.base.allocator, 1);
	194	try self.decls.putNoClobber(self.base.allocator, decl, {});
192	195
193		const block = &decl.link.wasm;
194		block.init = true;
	196	const atom = &decl.link.wasm;
195	197
196		if (self.offset_table_free_list.popOrNull()) \|index\| {
197		block.offset_index = index;
198		} else {
199		block.offset_index = @intCast(u32, self.offset_table.items.len);
200		_ = self.offset_table.addOneAssumeCapacity();
201		}
	198	var symbol: Symbol = .{
	199	.name = undefined, // will be set after updateDecl
	200	.flags = 0,
	201	.tag = undefined, // will be set after updateDecl
	202	.index = undefined, // will be set after updateDecl
	203	};
202	204
203	205	if (self.symbols_free_list.popOrNull()) \|index\| {
204		block.symbol_index = index;
205		self.symbols.items[block.symbol_index] = decl;
	206	atom.sym_index = index;
	207	self.symbols.items[index] = symbol;
206	208	} else {
207		block.symbol_index = @intCast(u32, self.symbols.items.len);
208		self.symbols.appendAssumeCapacity(decl);
209		}
210
211		self.offset_table.items[block.offset_index] = 0;
212
213		if (decl.ty.zigTypeTag() == .Fn) {
214		switch (decl.val.tag()) {
215		// dependent on function type, appends it to the correct list
216		.function => try self.funcs.append(self.base.allocator, decl),
217		.extern_fn => try self.ext_funcs.append(self.base.allocator, decl),
218		else => unreachable,
219		}
	209	atom.sym_index = @intCast(u32, self.symbols.items.len);
	210	self.symbols.appendAssumeCapacity(symbol);
220	211	}
221	212	}
222	213
...	...	@@ -228,25 +219,19 @@ pub fn updateFunc(self: Wasm, module: Module, func: *Module.Fn, air: Air, live
228	219	if (self.llvm_object) \|llvm_object\| return llvm_object.updateFunc(module, func, air, liveness);
229	220	}
230	221	const decl = func.owner_decl;
231		assert(decl.link.wasm.init); // Must call allocateDeclIndexes()
232
233		const fn_data = &decl.fn_link.wasm;
234		fn_data.functype.items.len = 0;
235		fn_data.code.items.len = 0;
236		fn_data.idx_refs.items.len = 0;
	222	assert(decl.link.wasm.sym_index != 0); // Must call allocateDeclIndexes()
237	223
238	224	var codegen: CodeGen = .{
239	225	.gpa = self.base.allocator,
240	226	.air = air,
241	227	.liveness = liveness,
242	228	.values = .{},
243		.code = fn_data.code.toManaged(self.base.allocator),
244		.func_type_data = fn_data.functype.toManaged(self.base.allocator),
	229	.code = std.ArrayList(u8).init(self.base.allocator),
245	230	.decl = decl,
246	231	.err_msg = undefined,
247	232	.locals = .{},
248	233	.target = self.base.options.target,
249		.bin_file = &self.base,
	234	.bin_file = self,
250	235	.global_error_set = self.base.options.module.?.global_error_set,
251	236	};
252	237	defer codegen.deinit();
...	...	@@ -272,26 +257,19 @@ pub fn updateDecl(self: Wasm, module: Module, decl: *Module.Decl) !void {
272	257	if (build_options.have_llvm) {
273	258	if (self.llvm_object) \|llvm_object\| return llvm_object.updateDecl(module, decl);
274	259	}
275		assert(decl.link.wasm.init); // Must call allocateDeclIndexes()
276
277		// TODO don't use this for non-functions
278		const fn_data = &decl.fn_link.wasm;
279		fn_data.functype.items.len = 0;
280		fn_data.code.items.len = 0;
281		fn_data.idx_refs.items.len = 0;
	260	assert(decl.link.wasm.sym_index != 0); // Must call allocateDeclIndexes()
282	261
283	262	var codegen: CodeGen = .{
284	263	.gpa = self.base.allocator,
285	264	.air = undefined,
286	265	.liveness = undefined,
287	266	.values = .{},
288		.code = fn_data.code.toManaged(self.base.allocator),
289		.func_type_data = fn_data.functype.toManaged(self.base.allocator),
	267	.code = std.ArrayList(u8).init(self.base.allocator),
290	268	.decl = decl,
291	269	.err_msg = undefined,
292	270	.locals = .{},
293	271	.target = self.base.options.target,
294		.bin_file = &self.base,
	272	.bin_file = self,
295	273	.global_error_set = self.base.options.module.?.global_error_set,
296	274	};
297	275	defer codegen.deinit();
...	...	@@ -310,33 +288,87 @@ pub fn updateDecl(self: Wasm, module: Module, decl: *Module.Decl) !void {
310	288	}
311	289
312	290	fn finishUpdateDecl(self: Wasm, decl: Module.Decl, result: CodeGen.Result, codegen: *CodeGen) !void {
313		const fn_data: *FnData = &decl.fn_link.wasm;
314
315		fn_data.code = codegen.code.toUnmanaged();
316		fn_data.functype = codegen.func_type_data.toUnmanaged();
317
318	291	const code: []const u8 = switch (result) {
319		.appended => @as([]const u8, fn_data.code.items),
	292	.appended => @as([]const u8, codegen.code.items),
320	293	.externally_managed => \|payload\| payload,
321	294	};
322	295
323		const block = &decl.link.wasm;
324		if (decl.ty.zigTypeTag() != .Fn) {
325		block.size = @intCast(u32, code.len);
326		block.data = code.ptr;
327		}
	296	const atom: *Atom = &decl.link.wasm;
	297	atom.size = @intCast(u32, code.len);
	298	try atom.code.appendSlice(self.base.allocator, code);
328	299
329	300	// If we're updating an existing decl, unplug it first
330	301	// to avoid infinite loops due to earlier links
331		block.unplug();
	302	atom.unplug();
332	303
333		if (self.last_block) \|last\| {
334		if (last != block) {
335		last.next = block;
336		block.prev = last;
337		}
	304	const symbol: *Symbol = &self.symbols.items[atom.sym_index];
	305	if (decl.isExtern()) {
	306	symbol.setUndefined(true);
	307	}
	308	symbol.name = decl.name;
	309	const final_index = switch (decl.ty.zigTypeTag()) {
	310	.Fn => result: {
	311	const type_index = decl.fn_link.wasm.type_index;
	312	const index = @intCast(u32, self.functions.items.len);
	313	try self.functions.append(self.base.allocator, .{ .type_index = type_index });
	314	symbol.tag = .function;
	315	symbol.index = index;
	316	atom.alignment = 1;
	317
	318	if (self.code_section_index == null) {
	319	self.code_section_index = @intCast(u32, self.segments.items.len);
	320	try self.segments.append(self.base.allocator, .{
	321	.alignment = atom.alignment,
	322	.size = atom.size,
	323	.offset = atom.offset,
	324	});
	325	} else {
	326	self.segments.items[self.code_section_index.?].size += atom.size;
	327	}
	328
	329	break :result self.code_section_index.?;
	330	},
	331	else => result: {
	332	const gop = try self.data_segments.getOrPut(self.base.allocator, ".rodata");
	333	const atom_index = if (gop.found_existing) blk: {
	334	self.segments.items[gop.value_ptr.*].size += atom.size;
	335	break :blk gop.value_ptr.*;
	336	} else blk: {
	337	const index = @intCast(u32, self.segments.items.len) - @boolToInt(self.code_section_index != null);
	338	try self.segments.append(self.base.allocator, .{
	339	.alignment = atom.alignment,
	340	.size = atom.size,
	341	.offset = atom.offset,
	342	});
	343	gop.value_ptr.* = index;
	344	break :blk index;
	345	};
	346	const info_index = @intCast(u32, self.segment_info.items.len);
	347	const segment_name = try std.mem.concat(self.base.allocator, u8, &.{
	348	".rodata.",
	349	std.mem.span(symbol.name),
	350	});
	351	errdefer self.base.allocator.free(segment_name);
	352	try self.segment_info.append(self.base.allocator, .{
	353	.name = segment_name,
	354	.alignment = atom.alignment,
	355	.flags = 0,
	356	});
	357	symbol.tag = .data;
	358	symbol.index = info_index;
	359	atom.alignment = decl.ty.abiAlignment(self.base.options.target);
	360	break :result atom_index;
	361	},
	362	};
	363
	364	if (self.atoms.getPtr(final_index)) \|last\| {
	365	last.*.next = atom;
	366	atom.prev = last.*;
	367	atom.offset = last..offset + last..size;
	368	last.* = atom;
	369	} else {
	370	try self.atoms.putNoClobber(self.base.allocator, final_index, atom);
338	371	}
339		self.last_block = block;
340	372	}
341	373
342	374	pub fn updateDeclExports(
...	...	@@ -358,29 +390,28 @@ pub fn freeDecl(self: Wasm, decl: Module.Decl) void {
358	390	if (self.llvm_object) \|llvm_object\| return llvm_object.freeDecl(decl);
359	391	}
360	392
361		if (self.getFuncidx(decl)) \|func_idx\| {
362		switch (decl.val.tag()) {
363		.function => _ = self.funcs.swapRemove(func_idx),
364		.extern_fn => _ = self.ext_funcs.swapRemove(func_idx),
365		else => unreachable,
366		}
367		}
368		const block = &decl.link.wasm;
	393	const atom = &decl.link.wasm;
369	394
370		if (self.last_block == block) {
371		self.last_block = block.prev;
	395	if (self.last_atom == atom) {
	396	self.last_atom = atom.prev;
372	397	}
373	398
374		block.unplug();
375
376		self.offset_table_free_list.append(self.base.allocator, decl.link.wasm.offset_index) catch {};
377		self.symbols_free_list.append(self.base.allocator, block.symbol_index) catch {};
378
379		block.init = false;
	399	atom.unplug();
	400	self.symbols_free_list.append(self.base.allocator, atom.sym_index) catch {};
	401	atom.deinit(self.base.allocator);
	402	_ = self.decls.remove(decl);
	403	}
380	404
381		decl.fn_link.wasm.functype.deinit(self.base.allocator);
382		decl.fn_link.wasm.code.deinit(self.base.allocator);
383		decl.fn_link.wasm.idx_refs.deinit(self.base.allocator);
	405	fn createUndefinedSymbol(self: Wasm, decl: Module.Decl, symbol_index: u32) !void {
	406	var symbol: *Symbol = &self.symbols.items[symbol_index];
	407	symbol.setUndefined(true);
	408	switch (decl.ty.zigTypeTag()) {
	409	.Fn => {
	410	symbol.setIndex(self.imported_functions_count);
	411	self.imported_functions_count += 1;
	412	},
	413	else => @panic("TODO: Wasm implement extern non-function types"),
	414	}
384	415	}
385	416
386	417	pub fn flush(self: Wasm, comp: Compilation) !void {
...	...	@@ -398,27 +429,20 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
398	429
399	430	const file = self.base.file.?;
400	431	const header_size = 5 + 1;
401		// ptr_width in bytes
402		const ptr_width = self.base.options.target.cpu.arch.ptrBitWidth() / 8;
403		// The size of the offset table in bytes
404		// The table contains all decl's with its corresponding offset into
405		// the 'data' section
406		const offset_table_size = @intCast(u32, self.offset_table.items.len * ptr_width);
407	432	// The size of the emulated stack
408	433	const stack_size = @intCast(u32, self.base.options.stack_size_override orelse std.wasm.page_size);
409	434
410		// The size of the data, this together with `offset_table_size` amounts to the
411		// total size of the 'data' section
412		var first_decl: ?*DeclBlock = null;
413		const data_size: u32 = if (self.last_block) \|last\| blk: {
414		var size = last.size;
415		var cur = last;
416		while (cur.prev) \|prev\| : (cur = prev) {
417		size += prev.size;
	435	var data_size: u32 = 0;
	436	for (self.segments.items) \|segment, index\| {
	437	// skip 'code' segments as they do not count towards data section size
	438	if (self.code_section_index) \|code_index\| {
	439	if (index == code_index) continue;
418	440	}
419		first_decl = cur;
420		break :blk size;
421		} else 0;
	441	data_size += segment.size;
	442	}
	443
	444	// set the stack size on the global
	445	self.globals.items[0].init = .{ .i32_const = @bitCast(i32, data_size + stack_size) };
422	446
423	447	// No need to rewrite the magic/version header
424	448	try file.setEndPos(@sizeOf(@TypeOf(wasm.magic ++ wasm.version)));
...	...	@@ -427,46 +451,62 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
427	451	// Type section
428	452	{
429	453	const header_offset = try reserveVecSectionHeader(file);
	454	const writer = file.writer();
430	455
431		// extern functions are defined in the wasm binary first through the `import`
432		// section, so define their func types first
433		for (self.ext_funcs.items) \|decl\| try file.writeAll(decl.fn_link.wasm.functype.items);
434		for (self.funcs.items) \|decl\| try file.writeAll(decl.fn_link.wasm.functype.items);
	456	for (self.func_types.items) \|func_type\| {
	457	try leb.writeULEB128(writer, wasm.function_type);
	458	try leb.writeULEB128(writer, @intCast(u32, func_type.params.len));
	459	for (func_type.params) \|param_ty\| try leb.writeULEB128(writer, wasm.valtype(param_ty));
	460	try leb.writeULEB128(writer, @intCast(u32, func_type.returns.len));
	461	for (func_type.returns) \|ret_ty\| try leb.writeULEB128(writer, wasm.valtype(ret_ty));
	462	}
435	463
436	464	try writeVecSectionHeader(
437	465	file,
438	466	header_offset,
439	467	.type,
440	468	@intCast(u32, (try file.getPos()) - header_offset - header_size),
441		@intCast(u32, self.ext_funcs.items.len + self.funcs.items.len),
	469	@intCast(u32, self.func_types.items.len),
442	470	);
443	471	}
444	472
445	473	// Import section
446		{
447		// TODO: implement non-functions imports
	474	if (self.import_symbols.items.len > 0) {
448	475	const header_offset = try reserveVecSectionHeader(file);
449	476	const writer = file.writer();
450		for (self.ext_funcs.items) \|decl, typeidx\| {
	477	for (self.import_symbols.items) \|symbol_index\| {
	478	const import_symbol = self.symbols.items[symbol_index];
	479	std.debug.assert(import_symbol.isUndefined());
451	480	try leb.writeULEB128(writer, @intCast(u32, self.host_name.len));
452	481	try writer.writeAll(self.host_name);
453	482
454		// wasm requires the length of the import name with no null-termination
455		const decl_len = mem.len(decl.name);
456		try leb.writeULEB128(writer, @intCast(u32, decl_len));
457		try writer.writeAll(decl.name[0..decl_len]);
458
459		// emit kind and the function type
460		try writer.writeByte(wasm.externalKind(.function));
461		try leb.writeULEB128(writer, @intCast(u32, typeidx));
	483	const name = std.mem.span(import_symbol.name);
	484	try leb.writeULEB128(writer, @intCast(u32, name.len));
	485	try writer.writeAll(name);
	486
	487	try writer.writeByte(wasm.externalKind(import_symbol.tag.externalType()));
	488	const import = self.findImport(import_symbol.index, import_symbol.tag.externalType()).?;
	489	switch (import.kind) {
	490	.function => \|type_index\| try leb.writeULEB128(writer, type_index),
	491	.global => \|global_type\| {
	492	try leb.writeULEB128(writer, wasm.valtype(global_type.valtype));
	493	try writer.writeByte(@boolToInt(global_type.mutable));
	494	},
	495	.table => \|table\| {
	496	try leb.writeULEB128(writer, wasm.reftype(table.reftype));
	497	try emitLimits(writer, table.limits);
	498	},
	499	.memory => \|limits\| {
	500	try emitLimits(writer, limits);
	501	},
	502	}
462	503	}
463
464	504	try writeVecSectionHeader(
465	505	file,
466	506	header_offset,
467	507	.import,
468	508	@intCast(u32, (try file.getPos()) - header_offset - header_size),
469		@intCast(u32, self.ext_funcs.items.len),
	509	@intCast(u32, self.imports.items.len),
470	510	);
471	511	}
472	512
...	...	@@ -474,9 +514,11 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
474	514	{
475	515	const header_offset = try reserveVecSectionHeader(file);
476	516	const writer = file.writer();
477		for (self.funcs.items) \|_, typeidx\| {
478		const func_idx = @intCast(u32, self.getFuncIdxOffset() + typeidx);
479		try leb.writeULEB128(writer, func_idx);
	517	for (self.functions.items) \|function\| {
	518	try leb.writeULEB128(
	519	writer,
	520	@intCast(u32, function.type_index),
	521	);
480	522	}
481	523
482	524	try writeVecSectionHeader(
...	...	@@ -484,7 +526,7 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
484	526	header_offset,
485	527	.function,
486	528	@intCast(u32, (try file.getPos()) - header_offset - header_size),
487		@intCast(u32, self.funcs.items.len),
	529	@intCast(u32, self.functions.items.len),
488	530	);
489	531	}
490	532
...	...	@@ -500,7 +542,7 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
500	542	writer,
501	543	try std.math.divCeil(
502	544	u32,
503		offset_table_size + data_size + stack_size,
	545	data_size + stack_size,
504	546	std.wasm.page_size,
505	547	),
506	548	);
...	...	@@ -515,29 +557,21 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
515	557
516	558	// Global section (used to emit stack pointer)
517	559	{
518		// We emit the emulated stack at the end of the data section,
519		// 'growing' downwards towards the program memory.
520		// TODO: Have linker resolve the offset table, so we can emit the stack
521		// at the start so we can't overwrite program memory with the stack.
522		const sp_value = offset_table_size + data_size + std.wasm.page_size;
523		const mutable = true; // stack pointer MUST be mutable
524	560	const header_offset = try reserveVecSectionHeader(file);
525	561	const writer = file.writer();
526	562
527		try writer.writeByte(wasm.valtype(.i32));
528		try writer.writeByte(@boolToInt(mutable));
529
530		// set the initial value of the stack pointer to the data size + stack size
531		try writer.writeByte(wasm.opcode(.i32_const));
532		try leb.writeILEB128(writer, @bitCast(i32, sp_value));
533		try writer.writeByte(wasm.opcode(.end));
	563	for (self.globals.items) \|global\| {
	564	try writer.writeByte(wasm.valtype(global.global_type.valtype));
	565	try writer.writeByte(@boolToInt(global.global_type.mutable));
	566	try emitInit(writer, global.init);
	567	}
534	568
535	569	try writeVecSectionHeader(
536	570	file,
537	571	header_offset,
538	572	.global,
539	573	@intCast(u32, (try file.getPos()) - header_offset - header_size),
540		@as(u32, 1),
	574	@intCast(u32, self.globals.items.len),
541	575	);
542	576	}
543	577
...	...	@@ -546,6 +580,7 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
546	580	const header_offset = try reserveVecSectionHeader(file);
547	581	const writer = file.writer();
548	582	var count: u32 = 0;
	583	var func_index: u32 = 0;
549	584	for (module.decl_exports.values()) \|exports\| {
550	585	for (exports) \|exprt\| {
551	586	// Export name length + name
...	...	@@ -557,7 +592,8 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
557	592	// Type of the export
558	593	try writer.writeByte(wasm.externalKind(.function));
559	594	// Exported function index
560		try leb.writeULEB128(writer, self.getFuncidx(exprt.exported_decl).?);
	595	try leb.writeULEB128(writer, func_index);
	596	func_index += 1;
561	597	},
562	598	else => return error.TODOImplementNonFnDeclsForWasm,
563	599	}
...	...	@@ -585,75 +621,108 @@ pub fn flushModule(self: Wasm, comp: Compilation) !void {
585	621	}
586	622
587	623	// Code section
588		{
	624	if (self.code_section_index) \|code_index\| {
589	625	const header_offset = try reserveVecSectionHeader(file);
590	626	const writer = file.writer();
591		for (self.funcs.items) \|decl\| {
592		const fn_data = &decl.fn_link.wasm;
593
594		// Write the already generated code to the file, inserting
595		// function indexes where required.
596		for (fn_data.idx_refs.items) \|idx_ref\| {
597		const relocatable_decl = self.symbols.items[idx_ref.decl];
598		const index = self.getFuncidx(relocatable_decl).?;
599		leb.writeUnsignedFixed(5, fn_data.code.items[idx_ref.offset..][0..5], index);
600		}
601		try writer.writeAll(fn_data.code.items);
	627	var atom = self.atoms.get(code_index).?.getFirst();
	628	while (true) {
	629	try leb.writeULEB128(writer, atom.size);
	630	try writer.writeAll(atom.code.items);
	631
	632	atom = atom.next orelse break;
602	633	}
603	634	try writeVecSectionHeader(
604	635	file,
605	636	header_offset,
606	637	.code,
607	638	@intCast(u32, (try file.getPos()) - header_offset - header_size),
608		@intCast(u32, self.funcs.items.len),
	639	@intCast(u32, self.functions.items.len),
609	640	);
610	641	}
611	642
612	643	// Data section
613		if (data_size != 0) {
	644	if (self.data_segments.count() != 0) {
614	645	const header_offset = try reserveVecSectionHeader(file);
615	646	const writer = file.writer();
616		// index to memory section (currently, there can only be 1 memory section in wasm)
617		try leb.writeULEB128(writer, @as(u32, 0));
618
619		// offset into data section
620		try writer.writeByte(wasm.opcode(.i32_const));
621		try leb.writeILEB128(writer, @as(i32, 0));
622		try writer.writeByte(wasm.opcode(.end));
623
624		const total_size = offset_table_size + data_size;
625	647
626		// offset table + data size
627		try leb.writeULEB128(writer, total_size);
628
629		// fill in the offset table and the data segments
630		const file_offset = try file.getPos();
631		var cur = first_decl;
632		var data_offset = offset_table_size;
633		while (cur) \|cur_block\| : (cur = cur_block.next) {
634		if (cur_block.size == 0) continue;
635		assert(cur_block.init);
636
637		const offset = (cur_block.offset_index) * ptr_width;
638		var buf: [4]u8 = undefined;
639		std.mem.writeIntLittle(u32, &buf, data_offset);
640
641		try file.pwriteAll(&buf, file_offset + offset);
642		try file.pwriteAll(cur_block.data[0..cur_block.size], file_offset + data_offset);
643		data_offset += cur_block.size;
	648	var it = self.data_segments.iterator();
	649	while (it.next()) \|entry\| {
	650	// do not output 'bss' section
	651	if (std.mem.eql(u8, entry.key_ptr.*, ".bss")) continue;
	652	const atom_index = entry.value_ptr.*;
	653	var atom = self.atoms.getPtr(atom_index).?.*.getFirst();
	654	var segment = self.segments.items[atom_index];
	655
	656	// flag and index to memory section (currently, there can only be 1 memory section in wasm)
	657	try leb.writeULEB128(writer, @as(u32, 0));
	658
	659	// offset into data section
	660	try writer.writeByte(wasm.opcode(.i32_const));
	661	try leb.writeILEB128(writer, @as(i32, 0));
	662	try writer.writeByte(wasm.opcode(.end));
	663
	664	// offset table + data size
	665	try leb.writeULEB128(writer, segment.size);
	666
	667	// fill in the offset table and the data segments
	668	var current_offset: u32 = 0;
	669	while (true) {
	670	std.debug.assert(current_offset == atom.offset);
	671	std.debug.assert(atom.code.items.len == atom.size);
	672
	673	try writer.writeAll(atom.code.items);
	674
	675	current_offset += atom.size;
	676	if (atom.next) \|next\| {
	677	atom = next;
	678	} else break;
	679	}
644	680	}
645	681
646		try file.seekTo(file_offset + data_offset);
647	682	try writeVecSectionHeader(
648	683	file,
649	684	header_offset,
650	685	.data,
651		@intCast(u32, (file_offset + data_offset) - header_offset - header_size),
	686	@intCast(u32, (try file.getPos()) - header_offset - header_size),
652	687	@intCast(u32, 1), // only 1 data section
653	688	);
654	689	}
655	690	}
656	691
	692	fn emitLimits(writer: anytype, limits: wasm.Limits) !void {
	693	try leb.writeULEB128(writer, @boolToInt(limits.max != null));
	694	try leb.writeULEB128(writer, limits.min);
	695	if (limits.max) \|max\| {
	696	try leb.writeULEB128(writer, max);
	697	}
	698	}
	699
	700	fn emitInit(writer: anytype, init_expr: wasm.InitExpression) !void {
	701	switch (init_expr) {
	702	.i32_const => \|val\| {
	703	try writer.writeByte(wasm.opcode(.i32_const));
	704	try leb.writeILEB128(writer, val);
	705	},
	706	.i64_const => \|val\| {
	707	try writer.writeByte(wasm.opcode(.i64_const));
	708	try leb.writeILEB128(writer, val);
	709	},
	710	.f32_const => \|val\| {
	711	try writer.writeByte(wasm.opcode(.f32_const));
	712	try writer.writeIntLittle(u32, @bitCast(u32, val));
	713	},
	714	.f64_const => \|val\| {
	715	try writer.writeByte(wasm.opcode(.f64_const));
	716	try writer.writeIntLittle(u64, @bitCast(u64, val));
	717	},
	718	.global_get => \|val\| {
	719	try writer.writeByte(wasm.opcode(.global_get));
	720	try leb.writeULEB128(writer, val);
	721	},
	722	}
	723	try writer.writeByte(wasm.opcode(.end));
	724	}
	725
657	726	fn linkWithLLD(self: Wasm, comp: Compilation) !void {
658	727	const tracy = trace(@src());
659	728	defer tracy.end();
...	...	@@ -970,32 +1039,6 @@ fn linkWithLLD(self: Wasm, comp: Compilation) !void {
970	1039	}
971	1040	}
972	1041
973		/// Get the current index of a given Decl in the function list
974		/// This will correctly provide the index, regardless whether the function is extern or not
975		/// TODO: we could maintain a hash map to potentially make this simpler
976		fn getFuncidx(self: Wasm, decl: *Module.Decl) ?u32 {
977		var offset: u32 = 0;
978		const slice = switch (decl.val.tag()) {
979		.function => blk: {
980		// when the target is a regular function, we have to calculate
981		// the offset of where the index starts
982		offset += self.getFuncIdxOffset();
983		break :blk self.funcs.items;
984		},
985		.extern_fn => self.ext_funcs.items,
986		else => return null,
987		};
988		return for (slice) \|func, idx\| {
989		if (func == decl) break @intCast(u32, offset + idx);
990		} else null;
991		}
992
993		/// Based on the size of `ext_funcs` returns the
994		/// offset of the function indices
995		fn getFuncIdxOffset(self: Wasm) u32 {
996		return @intCast(u32, self.ext_funcs.items.len);
997		}
998
999	1042	fn reserveVecSectionHeader(file: fs.File) !u64 {
1000	1043	// section id + fixed leb contents size + fixed leb vector length
1001	1044	const header_size = 1 + 5 + 5;
...	...	@@ -1012,3 +1055,36 @@ fn writeVecSectionHeader(file: fs.File, offset: u64, section: wasm.Section, size
1012	1055	leb.writeUnsignedFixed(5, buf[6..], items);
1013	1056	try file.pwriteAll(&buf, offset);
1014	1057	}
	1058
	1059	/// Searches for an a matching function signature, when not found
	1060	/// a new entry will be made. The index of the existing/new signature will be returned.
	1061	pub fn putOrGetFuncType(self: *Wasm, func_type: wasm.Type) !u32 {
	1062	var index: u32 = 0;
	1063	while (index < self.func_types.items.len) : (index += 1) {
	1064	if (self.func_types.items[index].eql(func_type)) return index;
	1065	}
	1066
	1067	// functype does not exist.
	1068	const params = try self.base.allocator.dupe(wasm.Valtype, func_type.params);
	1069	errdefer self.base.allocator.free(params);
	1070	const returns = try self.base.allocator.dupe(wasm.Valtype, func_type.returns);
	1071	errdefer self.base.allocator.free(returns);
	1072	try self.func_types.append(self.base.allocator, .{
	1073	.params = params,
	1074	.returns = returns,
	1075	});
	1076	return index;
	1077	}
	1078
	1079	/// From a given index and an `ExternalKind`, finds the corresponding Import.
	1080	/// This is due to indexes for imports being unique per type, rather than across all imports.
	1081	fn findImport(self: Wasm, index: u32, external_type: wasm.ExternalKind) ?*wasm.Import {
	1082	var current_index: u32 = 0;
	1083	for (self.imports.items) \|*import\| {
	1084	if (import.kind == external_type) {
	1085	if (current_index == index) return import;
	1086	current_index += 1;
	1087	}
	1088	}
	1089	return null;
	1090	}

src/link/Wasm/Atom.zig created+182

...	...	@@ -0,0 +1,182 @@
	1	const Atom = @This();
	2
	3	const std = @import("std");
	4	const types = @import("types.zig");
	5	const Wasm = @import("../Wasm.zig");
	6	const Symbol = @import("Symbol.zig");
	7
	8	const leb = std.leb;
	9	const log = std.log.scoped(.zld);
	10	const mem = std.mem;
	11	const Allocator = mem.Allocator;
	12
	13	/// symbol index of the symbol representing this atom
	14	sym_index: u32,
	15	/// Size of the atom, used to calculate section sizes in the final binary
	16	size: u32,
	17	/// List of relocations belonging to this atom
	18	relocs: std.ArrayListUnmanaged(types.Relocation) = .{},
	19	/// Contains the binary data of an atom, which can be non-relocated
	20	code: std.ArrayListUnmanaged(u8) = .{},
	21	/// For code this is 1, for data this is set to the highest value of all segments
	22	alignment: u32,
	23	/// Offset into the section where the atom lives, this already accounts
	24	/// for alignment.
	25	offset: u32,
	26
	27	/// Next atom in relation to this atom.
	28	/// When null, this atom is the last atom
	29	next: ?*Atom,
	30	/// Previous atom in relation to this atom.
	31	/// is null when this atom is the first in its order
	32	prev: ?*Atom,
	33
	34	/// Represents a default empty wasm `Atom`
	35	pub const empty: Atom = .{
	36	.alignment = 0,
	37	.next = null,
	38	.offset = 0,
	39	.prev = null,
	40	.size = 0,
	41	.sym_index = 0,
	42	};
	43
	44	/// Frees all resources owned by this `Atom`.
	45	/// Also destroys itself, making any usage of this atom illegal.
	46	pub fn deinit(self: Atom, gpa: Allocator) void {
	47	self.relocs.deinit(gpa);
	48	self.code.deinit(gpa);
	49	}
	50
	51	pub fn format(self: Atom, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
	52	_ = fmt;
	53	_ = options;
	54	writer.print("Atom{{ .sym_index = {d}, .alignment = {d}, .size = {d}, .offset = 0x{x:0>8} }}", .{
	55	self.sym_index,
	56	self.alignment,
	57	self.size,
	58	self.offset,
	59	});
	60	}
	61
	62	/// Returns the first `Atom` from a given atom
	63	pub fn getFirst(self: Atom) Atom {
	64	var tmp = self;
	65	while (tmp.prev) \|prev\| tmp = prev;
	66	return tmp;
	67	}
	68
	69	/// Returns the last `Atom` from a given atom
	70	pub fn getLast(self: Atom) Atom {
	71	var tmp = self;
	72	while (tmp.next) \|next\| tmp = next;
	73	return tmp;
	74	}
	75	/// Unplugs the `Atom` from the chain
	76	pub fn unplug(self: *Atom) void {
	77	if (self.prev) \|prev\| {
	78	prev.next = self.next;
	79	}
	80
	81	if (self.next) \|next\| {
	82	next.prev = self.prev;
	83	}
	84	self.next = null;
	85	self.prev = null;
	86	}
	87
	88	/// Resolves the relocations within the atom, writing the new value
	89	/// at the calculated offset.
	90	pub fn resolveRelocs(self: Atom, wasm_bin: const Wasm) !void {
	91	const object = wasm_bin.objects.items[self.file];
	92	const symbol: Symbol = object.symtable[self.sym_index];
	93
	94	log.debug("Resolving relocs in atom '{s}' count({d})", .{
	95	symbol.name,
	96	self.relocs.items.len,
	97	});
	98
	99	for (self.relocs.items) \|reloc\| {
	100	const value = self.relocationValue(reloc, wasm_bin);
	101	log.debug("Relocating '{s}' referenced in '{s}' offset=0x{x:0>8} value={d}", .{
	102	object.symtable[reloc.index].name,
	103	symbol.name,
	104	reloc.offset,
	105	value,
	106	});
	107
	108	switch (reloc.relocation_type) {
	109	.R_WASM_TABLE_INDEX_I32,
	110	.R_WASM_FUNCTION_OFFSET_I32,
	111	.R_WASM_GLOBAL_INDEX_I32,
	112	.R_WASM_MEMORY_ADDR_I32,
	113	.R_WASM_SECTION_OFFSET_I32,
	114	=> std.mem.writeIntLittle(u32, self.code.items[reloc.offset..][0..4], @intCast(u32, value)),
	115	.R_WASM_TABLE_INDEX_I64,
	116	.R_WASM_MEMORY_ADDR_I64,
	117	=> std.mem.writeIntLittle(u64, self.code.items[reloc.offset..][0..8], value),
	118	.R_WASM_GLOBAL_INDEX_LEB,
	119	.R_WASM_EVENT_INDEX_LEB,
	120	.R_WASM_FUNCTION_INDEX_LEB,
	121	.R_WASM_MEMORY_ADDR_LEB,
	122	.R_WASM_MEMORY_ADDR_SLEB,
	123	.R_WASM_TABLE_INDEX_SLEB,
	124	.R_WASM_TABLE_NUMBER_LEB,
	125	.R_WASM_TYPE_INDEX_LEB,
	126	=> leb.writeUnsignedFixed(5, self.code.items[reloc.offset..][0..5], @intCast(u32, value)),
	127	.R_WASM_MEMORY_ADDR_LEB64,
	128	.R_WASM_MEMORY_ADDR_SLEB64,
	129	.R_WASM_TABLE_INDEX_SLEB64,
	130	=> leb.writeUnsignedFixed(10, self.code.items[reloc.offset..][0..10], value),
	131	}
	132	}
	133	}
	134
	135	/// From a given `relocation` will return the new value to be written.
	136	/// All values will be represented as a `u64` as all values can fit within it.
	137	/// The final value must be casted to the correct size.
	138	fn relocationValue(self: Atom, relocation: types.Relocation, wasm_bin: const Wasm) u64 {
	139	const object = wasm_bin.objects.items[self.file];
	140	const symbol: Symbol = object.symtable[relocation.index];
	141	return switch (relocation.relocation_type) {
	142	.R_WASM_FUNCTION_INDEX_LEB => symbol.kind.function.functionIndex(),
	143	.R_WASM_TABLE_NUMBER_LEB => symbol.kind.table.table.table_idx,
	144	.R_WASM_TABLE_INDEX_I32,
	145	.R_WASM_TABLE_INDEX_I64,
	146	.R_WASM_TABLE_INDEX_SLEB,
	147	.R_WASM_TABLE_INDEX_SLEB64,
	148	=> symbol.getTableIndex() orelse 0,
	149	.R_WASM_TYPE_INDEX_LEB => symbol.kind.function.func.type_idx,
	150	.R_WASM_GLOBAL_INDEX_I32,
	151	.R_WASM_GLOBAL_INDEX_LEB,
	152	=> symbol.kind.global.global.global_idx,
	153	.R_WASM_MEMORY_ADDR_I32,
	154	.R_WASM_MEMORY_ADDR_I64,
	155	.R_WASM_MEMORY_ADDR_LEB,
	156	.R_WASM_MEMORY_ADDR_LEB64,
	157	.R_WASM_MEMORY_ADDR_SLEB,
	158	.R_WASM_MEMORY_ADDR_SLEB64,
	159	=> blk: {
	160	if (symbol.isUndefined() and (symbol.kind == .data or symbol.isWeak())) {
	161	return 0;
	162	}
	163	const segment_name = object.segment_info[symbol.index().?].outputName();
	164	const atom_index = wasm_bin.data_segments.get(segment_name).?;
	165	var target_atom = wasm_bin.atoms.getPtr(atom_index).?.*.getFirst();
	166	while (true) {
	167	if (target_atom.sym_index == relocation.index) break;
	168	if (target_atom.next) \|next\| {
	169	target_atom = next;
	170	} else break;
	171	}
	172	const segment = wasm_bin.segments.items[atom_index];
	173	const base = wasm_bin.options.global_base orelse 1024;
	174	const offset = target_atom.offset + segment.offset;
	175	break :blk offset + base + (relocation.addend orelse 0);
	176	},
	177	.R_WASM_EVENT_INDEX_LEB => symbol.kind.event.index,
	178	.R_WASM_SECTION_OFFSET_I32,
	179	.R_WASM_FUNCTION_OFFSET_I32,
	180	=> relocation.offset,
	181	};
	182	}

src/link/Wasm/Symbol.zig created+157

...	...	@@ -0,0 +1,157 @@
	1	//! Wasm symbols describing its kind,
	2	//! name and its properties.
	3	const Symbol = @This();
	4
	5	const std = @import("std");
	6	const types = @import("types.zig");
	7
	8	/// Bitfield containings flags for a symbol
	9	/// Can contain any of the flags defined in `Flag`
	10	flags: u32,
	11	/// Symbol name, when undefined this will be taken from the import.
	12	name: [*:0]const u8,
	13	/// An union that represents both the type of symbol
	14	/// as well as the data it holds.
	15	tag: Tag,
	16	/// Index into the list of objects based on set `tag`
	17	/// NOTE: This will be set to `undefined` when `tag` is `data`
	18	/// and the symbol is undefined.
	19	index: u32,
	20
	21	pub const Tag = enum {
	22	function,
	23	data,
	24	global,
	25	section,
	26	event,
	27	table,
	28
	29	/// From a given symbol tag, returns the `ExternalType`
	30	/// Asserts the given tag can be represented as an external type.
	31	pub fn externalType(self: Tag) std.wasm.ExternalKind {
	32	return switch (self) {
	33	.function => .function,
	34	.global => .global,
	35	.data => .memory,
	36	.section => unreachable, // Not an external type
	37	.event => unreachable, // Not an external type
	38	.table => .table,
	39	};
	40	}
	41	};
	42
	43	pub const Flag = enum(u32) {
	44	/// Indicates a weak symbol.
	45	/// When linking multiple modules defining the same symbol, all weak definitions are discarded
	46	/// in favourite of the strong definition. When no strong definition exists, all weak but one definiton is discarded.
	47	/// If multiple definitions remain, we get an error: symbol collision.
	48	WASM_SYM_BINDING_WEAK = 0x1,
	49	/// Indicates a local, non-exported, non-module-linked symbol.
	50	/// The names of local symbols are not required to be unique, unlike non-local symbols.
	51	WASM_SYM_BINDING_LOCAL = 0x2,
	52	/// Represents the binding of a symbol, indicating if it's local or not, and weak or not.
	53	WASM_SYM_BINDING_MASK = 0x3,
	54	/// Indicates a hidden symbol. Hidden symbols will not be exported to the link result, but may
	55	/// link to other modules.
	56	WASM_SYM_VISIBILITY_HIDDEN = 0x4,
	57	/// Indicates an undefined symbol. For non-data symbols, this must match whether the symbol is
	58	/// an import or is defined. For data symbols however, determines whether a segment is specified.
	59	WASM_SYM_UNDEFINED = 0x10,
	60	/// Indicates a symbol of which its intention is to be exported from the wasm module to the host environment.
	61	/// This differs from the visibility flag as this flag affects the static linker.
	62	WASM_SYM_EXPORTED = 0x20,
	63	/// Indicates the symbol uses an explicit symbol name, rather than reusing the name from a wasm import.
	64	/// Allows remapping imports from foreign WASM modules into local symbols with a different name.
	65	WASM_SYM_EXPLICIT_NAME = 0x40,
	66	/// Indicates the symbol is to be included in the linker output, regardless of whether it is used or has any references to it.
	67	WASM_SYM_NO_STRIP = 0x80,
	68	/// Indicates a symbol is TLS
	69	WASM_SYM_TLS = 0x100,
	70	};
	71
	72	/// Verifies if the given symbol should be imported from the
	73	/// host environment or not
	74	pub fn requiresImport(self: Symbol) bool {
	75	if (!self.isUndefined()) return false;
	76	if (self.isWeak()) return false;
	77	if (self.kind == .data) return false;
	78	// if (self.isDefined() and self.isWeak()) return true; //TODO: Only when building shared lib
	79
	80	return true;
	81	}
	82
	83	pub fn hasFlag(self: Symbol, flag: Flag) bool {
	84	return self.flags & @enumToInt(flag) != 0;
	85	}
	86
	87	pub fn setFlag(self: *Symbol, flag: Flag) void {
	88	self.flags \|= @enumToInt(flag);
	89	}
	90
	91	pub fn isUndefined(self: Symbol) bool {
	92	return self.flags & @enumToInt(Flag.WASM_SYM_UNDEFINED) != 0;
	93	}
	94
	95	pub fn setUndefined(self: *Symbol, is_undefined: bool) void {
	96	if (is_undefined) {
	97	self.setFlag(.WASM_SYM_UNDEFINED);
	98	} else {
	99	self.flags &= ~@enumToInt(Flag.WASM_SYM_UNDEFINED);
	100	}
	101	}
	102
	103	pub fn isDefined(self: Symbol) bool {
	104	return !self.isUndefined();
	105	}
	106
	107	pub fn isVisible(self: Symbol) bool {
	108	return self.flags & @enumToInt(Flag.WASM_SYM_VISIBILITY_HIDDEN) == 0;
	109	}
	110
	111	pub fn isLocal(self: Symbol) bool {
	112	return self.flags & @enumToInt(Flag.WASM_SYM_BINDING_LOCAL) != 0;
	113	}
	114
	115	pub fn isGlobal(self: Symbol) bool {
	116	return self.flags & @enumToInt(Flag.WASM_SYM_BINDING_LOCAL) == 0;
	117	}
	118
	119	pub fn isHidden(self: Symbol) bool {
	120	return self.flags & @enumToInt(Flag.WASM_SYM_VISIBILITY_HIDDEN) != 0;
	121	}
	122
	123	pub fn isNoStrip(self: Symbol) bool {
	124	return self.flags & @enumToInt(Flag.WASM_SYM_NO_STRIP) != 0;
	125	}
	126
	127	pub fn isExported(self: Symbol) bool {
	128	if (self.isUndefined() or self.isLocal()) return false;
	129	if (self.isHidden()) return false;
	130	return true;
	131	}
	132
	133	pub fn isWeak(self: Symbol) bool {
	134	return self.flags & @enumToInt(Flag.WASM_SYM_BINDING_WEAK) != 0;
	135	}
	136
	137	/// Formats the symbol into human-readable text
	138	pub fn format(self: Symbol, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
	139	_ = fmt;
	140	_ = options;
	141
	142	const kind_fmt: u8 = switch (self.kind) {
	143	.function => 'F',
	144	.data => 'D',
	145	.global => 'G',
	146	.section => 'S',
	147	.event => 'E',
	148	.table => 'T',
	149	};
	150	const visible: []const u8 = if (self.isVisible()) "yes" else "no";
	151	const binding: []const u8 = if (self.isLocal()) "local" else "global";
	152
	153	try writer.print(
	154	"{c} binding={s} visible={s} id={d} name={s}",
	155	.{ kind_fmt, binding, visible, self.index(), self.name },
	156	);
	157	}

src/link/Wasm/types.zig created+199

...	...	@@ -0,0 +1,199 @@
	1	//! This file contains all constants and related to wasm's object format.
	2
	3	const std = @import("std");
	4
	5	pub const Relocation = struct {
	6	/// Represents the type of the `Relocation`
	7	relocation_type: RelocationType,
	8	/// Offset of the value to rewrite relative to the relevant section's contents.
	9	/// When `offset` is zero, its position is immediately after the id and size of the section.
	10	offset: u32,
	11	/// The index of the symbol used.
	12	/// When the type is `R_WASM_TYPE_INDEX_LEB`, it represents the index of the type.
	13	index: u32,
	14	/// Addend to add to the address.
	15	/// This field is only non-null for `R_WASM_MEMORY_ADDR_*`, `R_WASM_FUNCTION_OFFSET_I32` and `R_WASM_SECTION_OFFSET_I32`.
	16	addend: ?u32 = null,
	17
	18	/// All possible relocation types currently existing.
	19	/// This enum is exhaustive as the spec is WIP and new types
	20	/// can be added which means that a generated binary will be invalid,
	21	/// so instead we will show an error in such cases.
	22	pub const RelocationType = enum(u8) {
	23	R_WASM_FUNCTION_INDEX_LEB = 0,
	24	R_WASM_TABLE_INDEX_SLEB = 1,
	25	R_WASM_TABLE_INDEX_I32 = 2,
	26	R_WASM_MEMORY_ADDR_LEB = 3,
	27	R_WASM_MEMORY_ADDR_SLEB = 4,
	28	R_WASM_MEMORY_ADDR_I32 = 5,
	29	R_WASM_TYPE_INDEX_LEB = 6,
	30	R_WASM_GLOBAL_INDEX_LEB = 7,
	31	R_WASM_FUNCTION_OFFSET_I32 = 8,
	32	R_WASM_SECTION_OFFSET_I32 = 9,
	33	R_WASM_EVENT_INDEX_LEB = 10,
	34	R_WASM_GLOBAL_INDEX_I32 = 13,
	35	R_WASM_MEMORY_ADDR_LEB64 = 14,
	36	R_WASM_MEMORY_ADDR_SLEB64 = 15,
	37	R_WASM_MEMORY_ADDR_I64 = 16,
	38	R_WASM_TABLE_INDEX_SLEB64 = 18,
	39	R_WASM_TABLE_INDEX_I64 = 19,
	40	R_WASM_TABLE_NUMBER_LEB = 20,
	41
	42	/// Returns true for relocation types where the `addend` field is present.
	43	pub fn addendIsPresent(self: RelocationType) bool {
	44	return switch (self) {
	45	.R_WASM_MEMORY_ADDR_LEB,
	46	.R_WASM_MEMORY_ADDR_SLEB,
	47	.R_WASM_MEMORY_ADDR_I32,
	48	.R_WASM_MEMORY_ADDR_LEB64,
	49	.R_WASM_MEMORY_ADDR_SLEB64,
	50	.R_WASM_MEMORY_ADDR_I64,
	51	.R_WASM_FUNCTION_OFFSET_I32,
	52	.R_WASM_SECTION_OFFSET_I32,
	53	=> true,
	54	else => false,
	55	};
	56	}
	57	};
	58
	59	/// Verifies the relocation type of a given `Relocation` and returns
	60	/// true when the relocation references a function call or address to a function.
	61	pub fn isFunction(self: Relocation) bool {
	62	return switch (self.relocation_type) {
	63	.R_WASM_FUNCTION_INDEX_LEB,
	64	.R_WASM_TABLE_INDEX_SLEB,
	65	=> true,
	66	else => false,
	67	};
	68	}
	69
	70	pub fn format(self: Relocation, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
	71	_ = fmt;
	72	_ = options;
	73	try writer.print("{s} offset=0x{x:0>6} symbol={d}", .{
	74	@tagName(self.relocation_type),
	75	self.offset,
	76	self.index,
	77	});
	78	}
	79	};
	80
	81	pub const SubsectionType = enum(u8) {
	82	WASM_SEGMENT_INFO = 5,
	83	WASM_INIT_FUNCS = 6,
	84	WASM_COMDAT_INFO = 7,
	85	WASM_SYMBOL_TABLE = 8,
	86	};
	87
	88	pub const Segment = struct {
	89	/// Segment's name, encoded as UTF-8 bytes.
	90	name: []const u8,
	91	/// The required alignment of the segment, encoded as a power of 2
	92	alignment: u32,
	93	/// Bitfield containing flags for a segment
	94	flags: u32,
	95
	96	pub fn outputName(self: Segment) []const u8 {
	97	if (std.mem.startsWith(u8, self.name, ".rodata.")) {
	98	return ".rodata";
	99	} else if (std.mem.startsWith(u8, self.name, ".text.")) {
	100	return ".text";
	101	} else if (std.mem.startsWith(u8, self.name, ".rodata.")) {
	102	return ".rodata";
	103	} else if (std.mem.startsWith(u8, self.name, ".data.")) {
	104	return ".data";
	105	} else if (std.mem.startsWith(u8, self.name, ".bss.")) {
	106	return ".bss";
	107	}
	108	return self.name;
	109	}
	110	};
	111
	112	pub const InitFunc = struct {
	113	/// Priority of the init function
	114	priority: u32,
	115	/// The symbol index of init function (not the function index).
	116	symbol_index: u32,
	117	};
	118
	119	pub const Comdat = struct {
	120	name: []const u8,
	121	/// Must be zero, no flags are currently defined by the tool-convention.
	122	flags: u32,
	123	symbols: []const ComdatSym,
	124	};
	125
	126	pub const ComdatSym = struct {
	127	kind: Type,
	128	/// Index of the data segment/function/global/event/table within a WASM module.
	129	/// The object must not be an import.
	130	index: u32,
	131
	132	pub const Type = enum(u8) {
	133	WASM_COMDAT_DATA = 0,
	134	WASM_COMDAT_FUNCTION = 1,
	135	WASM_COMDAT_GLOBAL = 2,
	136	WASM_COMDAT_EVENT = 3,
	137	WASM_COMDAT_TABLE = 4,
	138	WASM_COMDAT_SECTION = 5,
	139	};
	140	};
	141
	142	pub const Feature = struct {
	143	/// Provides information about the usage of the feature.
	144	/// - '0x2b' (+): Object uses this feature, and the link fails if feature is not in the allowed set.
	145	/// - '0x2d' (-): Object does not use this feature, and the link fails if this feature is in the allowed set.
	146	/// - '0x3d' (=): Object uses this feature, and the link fails if this feature is not in the allowed set,
	147	/// or if any object does not use this feature.
	148	prefix: Prefix,
	149	/// Type of the feature, must be unique in the sequence of features.
	150	tag: Tag,
	151
	152	pub const Tag = enum {
	153	atomics,
	154	bulk_memory,
	155	exception_handling,
	156	multivalue,
	157	mutable_globals,
	158	nontrapping_fptoint,
	159	sign_ext,
	160	simd128,
	161	tail_call,
	162	};
	163
	164	pub const Prefix = enum(u8) {
	165	used = '+',
	166	disallowed = '-',
	167	required = '=',
	168	};
	169
	170	pub fn toString(self: Feature) []const u8 {
	171	return switch (self.tag) {
	172	.bulk_memory => "bulk-memory",
	173	.exception_handling => "exception-handling",
	174	.mutable_globals => "mutable-globals",
	175	.nontrapping_fptoint => "nontrapping-fptoint",
	176	.sign_ext => "sign-ext",
	177	.tail_call => "tail-call",
	178	else => @tagName(self),
	179	};
	180	}
	181
	182	pub fn format(self: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
	183	_ = opt;
	184	_ = fmt;
	185	try writer.print("{c} {s}", .{ self.prefix, self.toString() });
	186	}
	187	};
	188
	189	pub const known_features = std.ComptimeStringMap(Feature.Tag, .{
	190	.{ "atomics", .atomics },
	191	.{ "bulk-memory", .bulk_memory },
	192	.{ "exception-handling", .exception_handling },
	193	.{ "multivalue", .multivalue },
	194	.{ "mutable-globals", .mutable_globals },
	195	.{ "nontrapping-fptoint", .nontrapping_fptoint },
	196	.{ "sign-ext", .sign_ext },
	197	.{ "simd128", .simd128 },
	198	.{ "tail-call", .tail_call },
	199	});