srctree

const sp = @intFromEnum(func.bin_file.zigObjectPtr().?.stack_pointer_sym);

try prologue.append(.{ .tag = .global_get, .data = .{ .label = sp } });

try prologue.append(.{ .tag = .global_set, .data = .{ .label = sp } });

try func.addLabel(.global_set, @intFromEnum(func.bin_file.zigObjectPtr().?.stack_pointer_sym));

atom.sym_index,

const atom_index = func.bin_file.zigObjectPtr().?.decls_map.get(direct).?.atom;

try func.addLabel(.call, @intFromEnum(func.bin_file.getAtom(atom_index).sym_index));

const fn_type_index = try func.bin_file.zigObjectPtr().?.putOrGetFuncType(func.gpa, fn_type);

const target_atom_index = func.bin_file.zigObjectPtr().?.anon_decls.get(decl_val).?;

const target_sym_index = @intFromEnum(func.bin_file.getAtom(target_atom_index).sym_index);

const target_sym_index = @intFromEnum(atom.sym_index);

const errors_len = WValue{ .memory = @intFromEnum(sym_index) };

const symbol_index = func.bin_file.getGlobalSymbol(name, null) catch |err| {

const func_type_index = try func.bin_file.zigObjectPtr().?.putOrGetFuncType(func.gpa, func_type);

try func.addLabel(.call, @intFromEnum(symbol_index));

return @intFromEnum(loc.index);

const sym_index = try func.bin_file.createFunction(func_name, func_type, &body_list, &relocs);

return @intFromEnum(sym_index);

const atom_index = emit.bin_file.zigObjectPtr().?.decls_map.get(emit.decl_index).?.atom;

const atom_index = emit.bin_file.zigObjectPtr().?.decls_map.get(emit.decl_index).?.atom;

const call_offset = emit.offset();

var buf: [5]u8 = undefined;

leb128.writeUnsignedFixed(5, &buf, type_index);

try emit.code.appendSlice(&buf);

if (type_index != 0) {

const atom_index = emit.bin_file.zigObjectPtr().?.decls_map.get(emit.decl_index).?.atom;

const atom = emit.bin_file.getAtomPtr(atom_index);

try atom.relocs.append(emit.bin_file.base.comp.gpa, .{

.offset = call_offset,

.index = type_index,

.relocation_type = .R_WASM_TYPE_INDEX_LEB,

});

}

const atom_index = emit.bin_file.zigObjectPtr().?.decls_map.get(emit.decl_index).?.atom;

const atom_index = emit.bin_file.zigObjectPtr().?.decls_map.get(emit.decl_index).?.atom;

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_line = wasm_file.getAtomPtr(wasm_file.debug_line_atom.?).code;

// writeDbgLineNopsBuffered(debug_line.items, src_fn.off, 0, &.{}, src_fn.len);

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const atom = wasm_file.getAtomPtr(wasm_file.debug_line_atom.?);

// const debug_line = &atom.code;

// const segment_size = debug_line.items.len;

// if (needed_size != segment_size) {

// log.debug(" needed size does not equal allocated size: {d}", .{needed_size});

// if (needed_size > segment_size) {

// log.debug(" allocating {d} bytes for 'debug line' information", .{needed_size - segment_size});

// try debug_line.resize(self.allocator, needed_size);

// @memset(debug_line.items[segment_size..], 0);

// }

// debug_line.items.len = needed_size;

// }

// writeDbgLineNopsBuffered(

// debug_line.items,

// src_fn.off,

// prev_padding_size,

// dbg_line_buffer.items,

// next_padding_size,

// );

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_info_index = wasm_file.debug_info_atom.?;

// const debug_info = &wasm_file.getAtomPtr(debug_info_index).code;

// try writeDbgInfoNopsToArrayList(gpa, debug_info, atom.off, 0, &.{0}, atom.len, false);

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const info_atom = wasm_file.debug_info_atom.?;

// const debug_info = &wasm_file.getAtomPtr(info_atom).code;

// const segment_size = debug_info.items.len;

// if (needed_size != segment_size) {

// log.debug(" needed size does not equal allocated size: {d}", .{needed_size});

// if (needed_size > segment_size) {

// log.debug(" allocating {d} bytes for 'debug info' information", .{needed_size - segment_size});

// try debug_info.resize(self.allocator, needed_size);

// @memset(debug_info.items[segment_size..], 0);

// }

// debug_info.items.len = needed_size;

// }

// log.debug(" writeDbgInfoNopsToArrayList debug_info_len={d} offset={d} content_len={d} next_padding_size={d}", .{

// debug_info.items.len, atom.off, dbg_info_buf.len, next_padding_size,

// });

// try writeDbgInfoNopsToArrayList(

// gpa,

// debug_info,

// atom.off,

// prev_padding_size,

// dbg_info_buf,

// next_padding_size,

// trailing_zero,

// );

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const offset = atom.off + self.getRelocDbgLineOff();

// const line_atom_index = wasm_file.debug_line_atom.?;

// wasm_file.getAtomPtr(line_atom_index).code.items[offset..][0..data.len].* = data;

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_abbrev = &wasm_file.getAtomPtr(wasm_file.debug_abbrev_atom.?).code;

// try debug_abbrev.resize(gpa, needed_size);

// debug_abbrev.items[0..abbrev_buf.len].* = abbrev_buf;

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_info = &wasm_file.getAtomPtr(wasm_file.debug_info_atom.?).code;

// try writeDbgInfoNopsToArrayList(self.allocator, debug_info, 0, 0, di_buf.items, jmp_amt, false);

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_ranges = &wasm_file.getAtomPtr(wasm_file.debug_ranges_atom.?).code;

// try debug_ranges.resize(gpa, needed_size);

// @memcpy(debug_ranges.items[0..di_buf.items.len], di_buf.items);

_ = &buffer;

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_line = &wasm_file.getAtomPtr(wasm_file.debug_line_atom.?).code;

// {

// const src = debug_line.items[first_fn.off..];

// @memcpy(buffer[0..src.len], src);

// }

// try debug_line.resize(self.allocator, debug_line.items.len + delta);

// @memcpy(debug_line.items[first_fn.off + delta ..][0..buffer.len], buffer);

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_line = &wasm_file.getAtomPtr(wasm_file.debug_line_atom.?).code;

// writeDbgLineNopsBuffered(debug_line.items, 0, 0, di_buf.items, jmp_amt);

// const wasm_file = self.bin_file.cast(File.Wasm).?;

// const debug_info = wasm_file.getAtomPtr(wasm_file.debug_info_atom.?).code;

// debug_info.items[atom.off + reloc.offset ..][0..buf.len].* = buf;

 

const build_options = @import("build_options");

const builtin = @import("builtin");

const codegen = @import("../codegen.zig");

const log = std.log.scoped(.link);

const gc_log = std.log.scoped(.gc);

const mem = std.mem;

const wasi_libc = @import("../wasi_libc.zig");

 

const Air = @import("../Air.zig");

const Allocator = std.mem.Allocator;

const Archive = @import("Wasm/Archive.zig");

const Cache = std.Build.Cache;

const CodeGen = @import("../arch/wasm/CodeGen.zig");

const Compilation = @import("../Compilation.zig");

const Dwarf = @import("Dwarf.zig");

const File = @import("Wasm/file.zig").File;

const InternPool = @import("../InternPool.zig");

const Liveness = @import("../Liveness.zig");

const LlvmObject = @import("../codegen/llvm.zig").Object;

const Module = @import("../Module.zig");

const Object = @import("Wasm/Object.zig");

const Symbol = @import("Wasm/Symbol.zig");

const Type = @import("../type.zig").Type;

const TypedValue = @import("../TypedValue.zig");

const ZigObject = @import("Wasm/ZigObject.zig");

 

pub const Atom = @import("Wasm/Atom.zig");

/// Symbol name of the entry function to export

/// When true, will allow undefined symbols

/// List of *global* symbol names to export to the host environment.

/// When defined, sets the start of the data section.

/// When defined, sets the initial memory size of the memory.

/// When defined, sets the maximum memory size of the memory.

/// When true, will import the function table from the host environment.

import_table: bool,

/// When true, will export the function table to the host environment.

export_table: bool,

/// The file index of a `ZigObject`. This will only contain a valid index when a zcu exists,

/// and the chosen backend is the Wasm backend.

zig_object_index: File.Index = .null,

/// List of relocatable files to be linked into the final binary.

files: std.MultiArrayList(File.Entry) = .{},

/// List of symbols generated by the linker.

synthetic_symbols: std.ArrayListUnmanaged(Symbol) = .{},

functions: std.AutoArrayHashMapUnmanaged(

struct { file: File.Index, index: u32 },

struct { func: std.wasm.Func, sym_index: Symbol.Index },

) = .{},

objects: std.ArrayListUnmanaged(File.Index) = .{},

index: Symbol.Index,

file: File.Index,

pub fn getSymbol(loc: SymbolLoc, wasm_file: *const Wasm) *Symbol {

if (wasm_file.discarded.get(loc)) |new_loc| {

return new_loc.getSymbol(wasm_file);

if (wasm_file.file(loc.file)) |obj_file| {

return obj_file.symbol(loc.index);

return &wasm_file.synthetic_symbols.items[@intFromEnum(loc.index)];

pub fn getName(loc: SymbolLoc, wasm_file: *const Wasm) []const u8 {

if (wasm_file.discarded.get(loc)) |new_loc| {

return new_loc.getName(wasm_file);

if (wasm_file.file(loc.file)) |obj_file| {

return obj_file.symbolName(loc.index);

const sym = wasm_file.synthetic_symbols.items[@intFromEnum(loc.index)];

return wasm_file.string_table.get(sym.name);

pub fn finalLoc(loc: SymbolLoc, wasm_file: *const Wasm) SymbolLoc {

if (wasm_file.discarded.get(loc)) |new_loc| {

return new_loc.finalLoc(wasm_file);

file: File.Index,

index: Symbol.Index,

wasm.base.file = try emit.directory.handle.createFile(sub_path, .{

symbol.mark();

symbol.mark();

symbol.mark();

if (comp.module) |zcu| {

if (!use_llvm) {

const index: File.Index = @enumFromInt(wasm.files.len);

var zig_object: ZigObject = .{

.index = index,

.path = try std.fmt.allocPrint(gpa, "{s}.o", .{std.fs.path.stem(zcu.main_mod.root_src_path)}),

.stack_pointer_sym = .null,

};

try zig_object.init(wasm);

try wasm.files.append(gpa, .{ .zig_object = zig_object });

wasm.zig_object_index = index;

}

}

 

pub fn file(wasm: *const Wasm, index: File.Index) ?File {

if (index == .null) return null;

const tag = wasm.files.items(.tags)[@intFromEnum(index)];

return switch (tag) {

.zig_object => .{ .zig_object = &wasm.files.items(.data)[@intFromEnum(index)].zig_object },

.object => .{ .object = &wasm.files.items(.data)[@intFromEnum(index)].object },

};

}

 

pub fn zigObjectPtr(wasm: *Wasm) ?*ZigObject {

if (wasm.zig_object_index == .null) return null;

return &wasm.files.items(.data)[@intFromEnum(wasm.zig_object_index)].zig_object;

}

 

pub fn getTypeIndex(wasm: *const Wasm, func_type: std.wasm.Type) ?u32 {

var index: u32 = 0;

while (index < wasm.func_types.items.len) : (index += 1) {

if (wasm.func_types.items[index].eql(func_type)) return index;

}

return null;

}

 

/// Either creates a new import, or updates one if existing.

/// When `type_index` is non-null, we assume an external function.

/// In all other cases, a data-symbol will be created instead.

pub fn addOrUpdateImport(

wasm: *Wasm,

/// Name of the import

name: []const u8,

/// Symbol index that is external

symbol_index: Symbol.Index,

/// Optional library name (i.e. `extern "c" fn foo() void`

lib_name: ?[:0]const u8,

/// The index of the type that represents the function signature

/// when the extern is a function. When this is null, a data-symbol

/// is asserted instead.

type_index: ?u32,

) !void {

return wasm.zigObjectPtr().?.addOrUpdateImport(wasm, name, symbol_index, lib_name, type_index);

}

 

const sym_index: Symbol.Index = @enumFromInt(wasm.synthetic_symbols.items.len);

const loc: SymbolLoc = .{ .index = sym_index, .file = .null };

try wasm.synthetic_symbols.append(gpa, .{

const obj_file = try fs.cwd().openFile(path, .{});

errdefer obj_file.close();

var object = Object.create(wasm, obj_file, path, null) catch |err| switch (err) {

else => |e| {

var err_note = try wasm.addErrorWithNotes(1);

try err_note.addMsg(wasm, "Failed parsing object file: {s}", .{@errorName(e)});

try err_note.addNote(wasm, "while parsing '{s}'", .{path});

return error.FlushFailure;

},

object.index = @enumFromInt(wasm.files.len);

try wasm.files.append(gpa, .{ .object = object });

try wasm.objects.append(gpa, object.index);

pub fn createAtom(wasm: *Wasm, sym_index: Symbol.Index, file_index: File.Index) !Atom.Index {

const index: Atom.Index = @enumFromInt(wasm.managed_atoms.items.len);

atom.* = .{ .file = file_index, .sym_index = sym_index };

try wasm.symbol_atom.putNoClobber(gpa, atom.symbolLoc(), index);

return wasm.managed_atoms.items[@intFromEnum(index)];

return &wasm.managed_atoms.items[@intFromEnum(index)];

const archive_file = try fs.cwd().openFile(path, .{});

errdefer archive_file.close();

.file = archive_file,

else => |e| {

var err_note = try wasm.addErrorWithNotes(1);

try err_note.addMsg(wasm, "Failed parsing archive: {s}", .{@errorName(e)});

try err_note.addNote(wasm, "while parsing archive {s}", .{path});

return error.FlushFailure;

},

var object = archive.parseObject(wasm, file_offset) catch |e| {

var err_note = try wasm.addErrorWithNotes(1);

try err_note.addMsg(wasm, "Failed parsing object: {s}", .{@errorName(e)});

try err_note.addNote(wasm, "while parsing object in archive {s}", .{path});

return error.FlushFailure;

};

object.index = @enumFromInt(wasm.files.len);

try wasm.files.append(gpa, .{ .object = object });

try wasm.objects.append(gpa, object.index);

fn resolveSymbolsInObject(wasm: *Wasm, file_index: File.Index) !void {

const obj_file = wasm.file(file_index).?;

log.debug("Resolving symbols in object: '{s}'", .{obj_file.path()});

for (obj_file.symbols(), 0..) |symbol, i| {

const sym_index: Symbol.Index = @enumFromInt(i);

const location: SymbolLoc = .{ .file = file_index, .index = sym_index };

const sym_name = obj_file.string(symbol.name);

var err = try wasm.addErrorWithNotes(1);

try err.addMsg(wasm, "Local symbols are not allowed to reference imports", .{});

try err.addNote(wasm, "symbol '{s}' defined in '{s}'", .{ sym_name, obj_file.path() });

const existing_file = wasm.file(existing_loc.file);

const existing_file_path = if (existing_file) |existing_obj_file|

existing_obj_file.path()

else

wasm.name;

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "symbol '{s}' defined multiple times", .{sym_name});

try err.addNote(wasm, "first definition in '{s}'", .{existing_file_path});

try err.addNote(wasm, "next definition in '{s}'", .{obj_file.path()});

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "symbol '{s}' mismatching types '{s}' and '{s}'", .{ sym_name, @tagName(symbol.tag), @tagName(existing_sym.tag) });

try err.addNote(wasm, "first definition in '{s}'", .{existing_file_path});

try err.addNote(wasm, "next definition in '{s}'", .{obj_file.path()});

const existing_name = if (existing_file) |existing_obj| blk: {

const imp = existing_obj.import(existing_loc.index);

break :blk existing_obj.string(imp.module_name);

const imp = obj_file.import(sym_index);

const module_name = obj_file.string(imp.module_name);

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "symbol '{s}' module name mismatch. Expected '{s}', but found '{s}'", .{

try err.addNote(wasm, "first definition in '{s}'", .{existing_file_path});

try err.addNote(wasm, "next definition in '{s}'", .{obj_file.path()});

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "symbol '{s}' mismatching global types", .{sym_name});

try err.addNote(wasm, "first definition in '{s}'", .{existing_file_path});

try err.addNote(wasm, "next definition in '{s}'", .{obj_file.path()});

var err = try wasm.addErrorWithNotes(3);

try err.addMsg(wasm, "symbol '{s}' mismatching function signatures.", .{sym_name});

try err.addNote(wasm, "expected signature {}, but found signature {}", .{ existing_ty, new_ty });

try err.addNote(wasm, "first definition in '{s}'", .{existing_file_path});

try err.addNote(wasm, "next definition in '{s}'", .{obj_file.path()});

log.debug(" new definition in '{s}'", .{obj_file.path()});

var object = archive.parseObject(wasm, offset.items[0]) catch |e| {

var err_note = try wasm.addErrorWithNotes(1);

try err_note.addMsg(wasm, "Failed parsing object: {s}", .{@errorName(e)});

try err_note.addNote(wasm, "while parsing object in archive {s}", .{archive.name});

return error.FlushFailure;

};

object.index = @enumFromInt(wasm.files.len);

try wasm.files.append(gpa, .{ .object = object });

try wasm.objects.append(gpa, object.index);

try wasm.resolveSymbolsInObject(object.index);

const sym_loc = try wasm.createSyntheticSymbol("__wasm_init_memory", .function);

sym_loc.getSymbol(wasm).mark();

const loc = try wasm.createSyntheticSymbol("__wasm_apply_global_tls_relocs", .function);

loc.getSymbol(wasm).mark();

for (wasm.objects.items) |file_index| {

const object: Object = wasm.files.items(.data)[@intFromEnum(file_index)].object;

const value = @as(u16, @intFromEnum(file_index)) << 1 | @as(u1, 1);

var err = try wasm.addErrorWithNotes(1);

try err.addMsg(wasm, "feature '{}' not allowed, but used by linked object", .{@as(types.Feature.Tag, @enumFromInt(used_index))});

try err.addNote(wasm, "defined in '{s}'", .{wasm.files.items(.data)[used_set >> 1].object.path});

return error.FlushFailure;

try wasm.addErrorWithoutNotes(

.{wasm.files.items(.data)[disallowed_feature >> 1].object.path},

try wasm.addErrorWithoutNotes("feature '{}' is not used but is required for shared-memory", .{feature});

try wasm.addErrorWithoutNotes("feature '{}' is not used but is required for thread-local storage", .{feature});

for (wasm.objects.items) |file_index| {

const object = wasm.files.items(.data)[@intFromEnum(file_index)].object;

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "feature '{}' is disallowed, but used by linked object", .{feature.tag});

try err.addNote(wasm, "disallowed by '{s}'", .{wasm.files.items(.data)[disallowed_feature >> 1].object.path});

try err.addNote(wasm, "used in '{s}'", .{object.path});

var err = try wasm.addErrorWithNotes(2);

try err.addMsg(wasm, "feature '{}' is required but not used in linked object", .{@as(types.Feature.Tag, @enumFromInt(feature_index))});

try err.addNote(wasm, "required by '{s}'", .{wasm.files.items(.data)[required_feature >> 1].object.path});

try err.addNote(wasm, "missing in '{s}'", .{object.path});

return error.FlushFailure;

const file_name = if (wasm.file(undef.file)) |obj_file|

obj_file.path()

else

wasm.name;

var err = try wasm.addErrorWithNotes(1);

try err.addMsg(wasm, "could not resolve undefined symbol '{s}'", .{symbol_name});

try err.addNote(wasm, "defined in '{s}'", .{file_name});

return error.FlushFailure;

if (wasm.zigObjectPtr()) |zig_obj| {

zig_obj.deinit(wasm);

}

for (wasm.objects.items) |obj_index| {

wasm.file(obj_index).?.object.deinit(gpa);

if (wasm.findGlobalSymbol("__wasm_init_tls")) |loc| {

const atom = wasm.symbol_atom.get(loc).?;

wasm.getAtomPtr(atom).deinit(gpa);

wasm.synthetic_symbols.deinit(gpa);

wasm.files.deinit(gpa);

try wasm.zigObjectPtr().?.updateFunc(wasm, mod, func_index, air, liveness);

try wasm.zigObjectPtr().?.updateDecl(wasm, mod, decl_index);

try wasm.zigObjectPtr().?.updateDeclLineNumber(mod, decl_index);

if (wasm.file(loc.file)) |obj_file| {

return obj_file.import(loc.index).kind.global;

return obj_file.globals()[symbol.index - obj_file.importedGlobals()].global_type;

if (wasm.file(loc.file)) |obj_file| {

const ty_index = obj_file.import(loc.index).kind.function;

return obj_file.funcTypes()[ty_index];

const type_index = obj_file.function(loc.index).type_index;

return obj_file.funcTypes()[type_index];

return wasm.zigObjectPtr().?.lowerUnnamedConst(wasm, tv, decl_index);

pub fn getGlobalSymbol(wasm: *Wasm, name: []const u8, lib_name: ?[]const u8) !Symbol.Index {

return wasm.zigObjectPtr().?.getGlobalSymbol(wasm.base.comp.gpa, name);

return wasm.zigObjectPtr().?.getDeclVAddr(wasm, decl_index, reloc_info);

return wasm.zigObjectPtr().?.lowerAnonDecl(wasm, decl_val, explicit_alignment, src_loc);

return wasm.zigObjectPtr().?.getAnonDeclVAddr(wasm, decl_val, reloc_info);

return wasm.zigObjectPtr().?.deleteDeclExport(wasm, decl_index, name);

return wasm.zigObjectPtr().?.updateExports(wasm, mod, exported, exports);

return wasm.zigObjectPtr().?.freeDecl(wasm, decl_index);

const sym = if (wasm.file(symbol_loc.file)) |obj_file|

obj_file.symbol(symbol_loc.index).*

else

wasm.synthetic_symbols.items[@intFromEnum(symbol_loc.index)];

if (entry.value_ptr.* == atom_index and atom.prev != .null) {

entry.value_ptr.* = atom.prev;

if (atom.prev == .null) break;

atom_index = atom.prev;

atom.prev = .null;

if (atom.prev == .null) break;

atom_index = atom.prev;

const segment_info = if (atom.file != .null)

wasm.file(atom.file).?.segmentInfo()

else

wasm.segment_info.values();

// There's no constructors for Zig so we can simply search through linked object files only.

for (wasm.objects.items) |file_index| {

const object: Object = wasm.files.items(.data)[@intFromEnum(file_index)].object;

const imp: types.Import = object.findImport(symbol);

const func_index = symbol.index - object.imported_functions_count;

try wasm.addErrorWithoutNotes("constructor functions cannot take arguments: '{s}'", .{object.string_table.get(symbol.name)});

.index = @enumFromInt(init_func.symbol_index),

.file = file_index,

try wasm.mark(.{ .index = @enumFromInt(init_func.symbol_index), .file = file_index });

const loc = wasm.findGlobalSymbol(symbol_name).?; // forgot to create symbol?

.{ .file = .null, .index = func_index },

const atom_index = try wasm.createAtom(loc.index, .null);

const atom = wasm.getAtomPtr(atom_index);

atom.size = @intCast(function_body.items.len);

atom.code = function_body.moveToUnmanaged();

/// the codegeneration backend. This will not allocate the created Atom yet.

) !Symbol.Index {

return wasm.zigObjectPtr().?.createFunction(wasm, symbol_name, func_ty, function_body, relocations);

// ensure function is marked as we must emit it

wasm.findGlobalSymbol("__wasm_init_tls").?.getSymbol(wasm).mark();

 

loc.getSymbol(wasm).mark();

const obj_file = wasm.file(symbol_loc.file) orelse {

// Synthetic symbols will already exist in the `import` section

const import = obj_file.import(symbol_loc.index);

.module_name = try wasm.string_table.put(gpa, obj_file.string(import.module_name)),

.name = try wasm.string_table.put(gpa, obj_file.string(import.name)),

const obj_file = wasm.file(sym_loc.file) orelse {

// Synthetic symbols already live in the corresponding sections.

};

const symbol = obj_file.symbol(sym_loc.index);

if (symbol.isDead() or symbol.isUndefined()) {

// we favor keeping the global over a local.

const original_loc: SymbolLoc = .{ .file = gop.key_ptr.file, .index = gop.value_ptr.sym_index };

const original_sym = original_loc.getSymbol(wasm);

if (original_sym.isLocal() and symbol.isGlobal()) {

original_sym.unmark();

try wasm.discarded.put(gpa, original_loc, sym_loc);

try removed_duplicates.append(original_loc);

} else {

symbol.unmark();

try wasm.discarded.putNoClobber(gpa, sym_loc, original_loc);

try removed_duplicates.append(sym_loc);

continue;

}

gop.value_ptr.* = .{ .func = obj_file.function(sym_loc.index), .sym_index = sym_loc.index };

const index = symbol.index - obj_file.importedFunctions();

const original_global = obj_file.globals()[index];

const index = symbol.index - obj_file.importedFunctions();

// assert it's a regular relocatable object file as `ZigObject` will never

// contain a table.

const original_table = obj_file.object.tables[index];

.dead, .undefined => unreachable,

else => {},

gc_log.debug("Removed duplicate for function '{s}'", .{sym_loc.getName(wasm)});

const obj_file = wasm.file(sym_loc.file) orelse {

};

 

const symbol = obj_file.symbol(sym_loc.index);

const original_type = obj_file.funcTypes()[import.kind.function];

func.type_index = try wasm.putOrGetFuncType(obj_file.funcTypes()[func.type_index]);

fn checkExportNames(wasm: *Wasm) !void {

try wasm.addErrorWithoutNotes("could not export '{s}', symbol not found", .{exp_name});

return error.FlushFailure;

}

 

fn setupExports(wasm: *Wasm) !void {

const comp = wasm.base.comp;

const gpa = comp.gpa;

if (comp.config.output_mode == .Obj) return;

log.debug("Building exports from symbols", .{});

const export_name = if (sym_loc.file == .null)

symbol.name

else

try wasm.string_table.put(gpa, sym_name);

try wasm.addErrorWithoutNotes("Entry symbol '{s}' missing, use '-fno-entry' to suppress", .{entry_name});

return error.FlushFailure;

try wasm.addErrorWithoutNotes("Entry symbol '{s}' is not a function", .{entry_name});

return error.FlushFailure;

const stack_ptr = if (wasm.findGlobalSymbol("__stack_pointer")) |loc| index: {

const sym = loc.getSymbol(wasm);

break :index sym.index - wasm.imported_globals_count;

} else null;

 

if (stack_ptr) |index| {

wasm.wasm_globals.items[index].init.i32_const = @as(i32, @bitCast(@as(u32, @intCast(memory_ptr))));

}

sym.mark();

if (stack_ptr) |index| {

wasm.wasm_globals.items[index].init.i32_const = @as(i32, @bitCast(@as(u32, @intCast(memory_ptr))));

}

try wasm.addErrorWithoutNotes("Initial memory must be {d}-byte aligned", .{page_size});

try wasm.addErrorWithoutNotes("Initial memory too small, must be at least {d} bytes", .{memory_ptr});

try wasm.addErrorWithoutNotes("Initial memory exceeds maximum memory {d}", .{max_memory_allowed});

try wasm.addErrorWithoutNotes("Maximum memory must be {d}-byte aligned", .{page_size});

try wasm.addErrorWithoutNotes("Maxmimum memory too small, must be at least {d} bytes", .{memory_ptr});

try wasm.addErrorWithoutNotes("Maximum memory exceeds maxmium amount {d}", .{max_memory_allowed});

pub fn getMatchingSegment(wasm: *Wasm, file_index: File.Index, symbol_index: Symbol.Index) !u32 {

const obj_file = wasm.file(file_index).?;

const symbol = obj_file.symbols()[@intFromEnum(symbol_index)];

const segment_info = obj_file.segmentInfo()[symbol.index];

const section_name = obj_file.symbolName(symbol_index);

var err = try wasm.addErrorWithNotes(1);

try err.addMsg(wasm, "found unknown section '{s}'", .{section_name});

try err.addNote(wasm, "defined in '{s}'", .{obj_file.path()});

return wasm.flushModule(arena, prog_node);

pub fn flushModule(wasm: *Wasm, arena: Allocator, prog_node: *std.Progress.Node) link.File.FlushError!void {

if (wasm.llvm_object) |llvm_object| {

try wasm.base.emitLlvmObject(arena, llvm_object, prog_node);

const use_lld = build_options.have_llvm and comp.config.use_lld;

if (use_lld) return;

}

const directory = wasm.base.emit.directory; // Just an alias to make it shorter to type.

const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});

const module_obj_path: ?[]const u8 = if (wasm.base.zcu_object_sub_path) |path| blk: {

if (fs.path.dirname(full_out_path)) |dirname| {

break :blk try fs.path.join(arena, &.{ dirname, path });

} else {

break :blk path;

} else null;

try positionals.ensureUnusedCapacity(comp.objects.len);

if (wasm.zigObjectPtr()) |zig_object| {

try zig_object.flushModule(wasm);

}

 

for (comp.objects) |object| {

if (wasm.zig_object_index != .null) {

try wasm.resolveSymbolsInObject(wasm.zig_object_index);

if (comp.link_errors.items.len > 0) return error.FlushFailure;

for (wasm.objects.items) |object_index| {

try wasm.resolveSymbolsInObject(object_index);

}

if (comp.link_errors.items.len > 0) return error.FlushFailure;

if (comp.link_errors.items.len > 0) return error.FlushFailure;

try wasm.checkExportNames();

if (comp.link_errors.items.len > 0) return error.FlushFailure;

if (comp.link_errors.items.len > 0) return error.FlushFailure;

if (comp.link_errors.items.len > 0) return error.FlushFailure;

const sym = symbol_loc_ptr.getSymbol(wasm);

std.debug.assert(sym.isAlive());

std.debug.assert(sym.index < wasm.functions.count() + wasm.imported_functions_count);

if (atom.prev != .null) {

atom_index = atom.prev;

else => |mode| try wasm.addErrorWithoutNotes("build-id '{s}' is not supported for WebAssembly", .{@tagName(mode)}),

if (atom.prev == .null) break;

atom = wasm.getAtomPtr(atom.prev);

const sym_name = sym_loc.getName(wasm);

const sym_loc: SymbolLoc = .{ .file = atom.file, .index = @enumFromInt(relocation.index) };

if (atom.prev == .null) break;

atom = wasm.getAtomPtr(atom.prev);

const sym_loc: SymbolLoc = .{ .file = atom.file, .index = @enumFromInt(relocation.index) };

if (atom.prev == .null) break;

atom = wasm.getAtomPtr(atom.prev);

const gpa = wasm.base.comp.gpa;

return wasm.zigObjectPtr().?.storeDeclType(wasm.base.comp.gpa, decl_index, func_type);

}

 

/// Returns the symbol index of the error name table.

///

/// When the symbol does not yet exist, it will create a new one instead.

pub fn getErrorTableSymbol(wasm_file: *Wasm) !u32 {

const sym_index = try wasm_file.zigObjectPtr().?.getErrorTableSymbol(wasm_file);

return @intFromEnum(sym_index);

}

 

/// For a given `InternPool.DeclIndex` returns its corresponding `Atom.Index`.

/// When the index was not found, a new `Atom` will be created, and its index will be returned.

/// The newly created Atom is empty with default fields as specified by `Atom.empty`.

pub fn getOrCreateAtomForDecl(wasm_file: *Wasm, decl_index: InternPool.DeclIndex) !Atom.Index {

return wasm_file.zigObjectPtr().?.getOrCreateAtomForDecl(wasm_file, decl_index);

const obj_file = wasm.file(sym_loc.file) orelse continue; // Incremental debug info is done independently

_ = try obj_file.parseSymbolIntoAtom(wasm, sym_loc.index);

sym.mark();

gc_log.debug("Marked symbol '{s}'", .{loc.getName(wasm)});

const atom_index = if (wasm.file(loc.file)) |obj_file|

try obj_file.parseSymbolIntoAtom(wasm, loc.index)

else

wasm.symbol_atom.get(loc) orelse return;

const target_loc: SymbolLoc = .{ .index = @enumFromInt(reloc.index), .file = loc.file };

 

const ErrorWithNotes = struct {

/// Allocated index in comp.link_errors array.

index: usize,

 

/// Next available note slot.

note_slot: usize = 0,

 

pub fn addMsg(

err: ErrorWithNotes,

wasm_file: *const Wasm,

comptime format: []const u8,

args: anytype,

) error{OutOfMemory}!void {

const comp = wasm_file.base.comp;

const gpa = comp.gpa;

const err_msg = &comp.link_errors.items[err.index];

err_msg.msg = try std.fmt.allocPrint(gpa, format, args);

}

 

pub fn addNote(

err: *ErrorWithNotes,

wasm_file: *const Wasm,

comptime format: []const u8,

args: anytype,

) error{OutOfMemory}!void {

const comp = wasm_file.base.comp;

const gpa = comp.gpa;

const err_msg = &comp.link_errors.items[err.index];

err_msg.notes[err.note_slot] = .{ .msg = try std.fmt.allocPrint(gpa, format, args) };

err.note_slot += 1;

}

};

 

pub fn addErrorWithNotes(wasm: *const Wasm, note_count: usize) error{OutOfMemory}!ErrorWithNotes {

const comp = wasm.base.comp;

const gpa = comp.gpa;

try comp.link_errors.ensureUnusedCapacity(gpa, 1);

return wasm.addErrorWithNotesAssumeCapacity(note_count);

}

 

pub fn addErrorWithoutNotes(wasm: *const Wasm, comptime fmt: []const u8, args: anytype) !void {

const err = try wasm.addErrorWithNotes(0);

try err.addMsg(wasm, fmt, args);

}

 

fn addErrorWithNotesAssumeCapacity(wasm: *const Wasm, note_count: usize) error{OutOfMemory}!ErrorWithNotes {

const comp = wasm.base.comp;

const gpa = comp.gpa;

const index = comp.link_errors.items.len;

const err = comp.link_errors.addOneAssumeCapacity();

err.* = .{ .msg = undefined, .notes = try gpa.alloc(link.File.ErrorMsg, note_count) };

return .{ .index = index };

}

reader.readNoEof(sym_tab) catch return error.IncompleteSymbolTable;

return error.InvalidHeaderDelimiter;

return error.MissingTableName;

pub fn parseObject(archive: Archive, wasm_file: *const Wasm, file_offset: u32) !Object {

const gpa = wasm_file.base.comp.gpa;

return error.InvalidHeaderDelimiter;

break :name try std.fmt.allocPrint(gpa, "{s}({s})", .{ path, object_name });

defer gpa.free(name);

return Object.create(wasm_file, object_file, name, object_file_size);

 

const std = @import("std");

const assert = std.debug.assert;

const fs = std.fs;

const log = std.log.scoped(.archive);

const mem = std.mem;

 

const Allocator = mem.Allocator;

const Object = @import("Object.zig");

const Wasm = @import("../Wasm.zig");

 

const Archive = @This();

/// Represents the index of the file this atom was generated from.

/// This is 'null' when the atom was generated by a synthetic linker symbol.

file: FileIndex,

sym_index: Symbol.Index,

size: u32 = 0,

alignment: Wasm.Alignment = .@"1",

offset: u32 = 0,

original_offset: u32 = 0,

prev: Atom.Index = .null,

/// Represents the index of an Atom where `null` is considered

/// an invalid atom.

pub const Index = enum(u32) {

null = std.math.maxInt(u32),

_,

@intFromEnum(atom.sym_index),

(Wasm.SymbolLoc{ .file = atom.file, .index = @enumFromInt(reloc.index) }).getName(wasm_bin),

const target_loc = (Wasm.SymbolLoc{ .file = atom.file, .index = @enumFromInt(relocation.index) }).finalLoc(wasm_bin);

=> return wasm_bin.function_table.get(.{ .file = atom.file, .index = @enumFromInt(relocation.index) }) orelse 0,

const obj_file = wasm_bin.file(atom.file) orelse return relocation.index;

const original_type = obj_file.funcTypes()[relocation.index];

 

const leb = std.leb;

const log = std.log.scoped(.link);

const mem = std.mem;

const std = @import("std");

const types = @import("types.zig");

 

const Allocator = mem.Allocator;

const Atom = @This();

const FileIndex = @import("file.zig").File.Index;

const Symbol = @import("Symbol.zig");

const Wasm = @import("../Wasm.zig");

const File = @import("file.zig").File;

const log = std.log.scoped(.object);

/// Index into the list of relocatable object files within the linker driver.

index: File.Index = .null,

path: []const u8,

/// Amount of functions in the `import` sections.

imported_functions_count: u32 = 0,

/// Amount of globals in the `import` section.

imported_globals_count: u32 = 0,

/// Amount of tables in the `import` section.

imported_tables_count: u32 = 0,

pub fn create(wasm_file: *const Wasm, file: std.fs.File, name: []const u8, maybe_max_size: ?usize) InitError!Object {

const gpa = wasm_file.base.comp.gpa;

.path = try gpa.dupe(u8, name),

errdefer gpa.free(object.path);

try object.parse(gpa, wasm_file, fbs.reader(), &is_object_file);

gpa.free(object.path);

pub fn findImport(object: *const Object, sym: Symbol) types.Import {

if (std.meta.activeTag(import.kind) == sym.tag.externalType()) {

if (i == sym.index) return import;

fn checkLegacyIndirectFunctionTable(object: *Object, wasm_file: *const Wasm) !?Symbol {

if (object.imported_tables_count == table_count) return null;

var err = try wasm_file.addErrorWithNotes(1);

try err.addMsg(wasm_file, "Expected a table entry symbol for each of the {d} table(s), but instead got {d} symbols.", .{

object.imported_tables_count,

try err.addNote(wasm_file, "defined in '{s}'", .{object.path});

var err = try wasm_file.addErrorWithNotes(1);

try err.addMsg(wasm_file, "Unexpected table definition without representing table symbols.", .{});

try err.addNote(wasm_file, "defined in '{s}'", .{object.path});

if (object.imported_tables_count != 1) {

var err = try wasm_file.addErrorWithNotes(1);

try err.addMsg(wasm_file, "Found more than one table import, but no representing table symbols", .{});

try err.addNote(wasm_file, "defined in '{s}'", .{object.path});

var err = try wasm_file.addErrorWithNotes(1);

try err.addMsg(wasm_file, "Non-indirect function table import '{s}' is missing a corresponding symbol", .{object.string_table.get(table_import.name)});

try err.addNote(wasm_file, "defined in '{s}'", .{object.path});

fn parse(object: *Object, gpa: Allocator, wasm_file: *const Wasm, reader: anytype, is_object_file: *bool) Parser(@TypeOf(reader)).Error!void {

var parser = Parser(@TypeOf(reader)).init(object, wasm_file, reader);

/// Read-only reference to the WebAssembly linker

wasm_file: *const Wasm,

fn init(object: *Object, wasm_file: *const Wasm, reader: ReaderType) ObjectParser {

return .{ .object = object, .wasm_file = wasm_file, .reader = std.io.countingReader(reader) };

.function => val: {

parser.object.imported_functions_count += 1;

break :val .{ .function = try readLeb(u32, reader) };

},

.global => val: {

parser.object.imported_globals_count += 1;

break :val .{ .global = .{

.valtype = try readEnum(std.wasm.Valtype, reader),

.mutable = (try reader.readByte()) == 0x01,

} };

},

.table => val: {

parser.object.imported_tables_count += 1;

break :val .{ .table = .{

.reftype = try readEnum(std.wasm.RefType, reader),

.limits = try readLimits(reader),

} };

},

const imported_function_count = parser.object.imported_functions_count;

var err = try parser.wasm_file.addErrorWithNotes(1);

try err.addMsg(parser.wasm_file, "Object file contains unknown feature: {s}", .{name});

try err.addNote(parser.wasm_file, "defined in '{s}'", .{parser.object.path});

if (try parser.object.checkLegacyIndirectFunctionTable(parser.wasm_file)) |symbol| {

} else parser.object.findImport(symbol).name;

pub fn parseSymbolIntoAtom(object: *Object, wasm: *Wasm, symbol_index: Symbol.Index) !Atom.Index {

const symbol = &object.symtable[@intFromEnum(symbol_index)];

.function => object.relocatable_data.get(.code).?[symbol.index - object.imported_functions_count],

const final_index = try wasm.getMatchingSegment(object.index, symbol_index);

const atom_index = try wasm.createAtom(symbol_index, object.index);

const atom = wasm.getAtomPtr(atom_index);

 

.file = object.index,

.index = @enumFromInt(reloc.index),

try wasm.got_symbols.append(gpa, .{ .file = object.index, .index = @enumFromInt(reloc.index) });

//! Represents a WebAssembly symbol. Containing all of its properties,

/// Represents a symbol index where `null` represents an invalid index.

pub const Index = enum(u32) {

null,

_,

};

 

 

const std = @import("std");

const types = @import("types.zig");

const Symbol = @This();

//! ZigObject encapsulates the state of the incrementally compiled Zig module.

//! It stores the associated input local and global symbols, allocated atoms,

//! and any relocations that may have been emitted.

//! Think about this as fake in-memory Object file for the Zig module.

 

path: []const u8,

/// Index within the list of relocatable objects of the linker driver.

index: File.Index,

/// Map of all `Decl` that are currently alive.

/// Each index maps to the corresponding `DeclInfo`.

decls_map: std.AutoHashMapUnmanaged(InternPool.DeclIndex, DeclInfo) = .{},

/// List of function type signatures for this Zig module.

func_types: std.ArrayListUnmanaged(std.wasm.Type) = .{},

/// List of `std.wasm.Func`. Each entry contains the function signature,

/// rather than the actual body.

functions: std.ArrayListUnmanaged(std.wasm.Func) = .{},

/// List of indexes pointing to an entry within the `functions` list which has been removed.

functions_free_list: std.ArrayListUnmanaged(u32) = .{},

/// Map of symbol locations, represented by its `types.Import`.

imports: std.AutoHashMapUnmanaged(Symbol.Index, types.Import) = .{},

/// List of WebAssembly globals.

globals: std.ArrayListUnmanaged(std.wasm.Global) = .{},

/// Mapping between an `Atom` and its type index representing the Wasm

/// type of the function signature.

atom_types: std.AutoHashMapUnmanaged(Atom.Index, u32) = .{},

/// List of all symbols generated by Zig code.

symbols: std.ArrayListUnmanaged(Symbol) = .{},

/// Map from symbol name offset to their index into the `symbols` list.

global_syms: std.AutoHashMapUnmanaged(u32, Symbol.Index) = .{},

/// List of symbol indexes which are free to be used.

symbols_free_list: std.ArrayListUnmanaged(Symbol.Index) = .{},

/// Extra metadata about the linking section, such as alignment of segments and their name.

segment_info: std.ArrayListUnmanaged(types.Segment) = .{},

/// List of indexes which contain a free slot in the `segment_info` list.

segment_free_list: std.ArrayListUnmanaged(u32) = .{},

/// File encapsulated string table, used to deduplicate strings within the generated file.

string_table: StringTable = .{},

/// Map for storing anonymous declarations. Each anonymous decl maps to its Atom's index.

anon_decls: std.AutoArrayHashMapUnmanaged(InternPool.Index, Atom.Index) = .{},

/// List of atom indexes of functions that are generated by the backend.

synthetic_functions: std.ArrayListUnmanaged(Atom.Index) = .{},

/// Represents the symbol index of the error name table

/// When this is `null`, no code references an error using runtime `@errorName`.

/// During initializion, a symbol with corresponding atom will be created that is

/// used to perform relocations to the pointer of this table.

/// The actual table is populated during `flush`.

error_table_symbol: Symbol.Index = .null,

/// Atom index of the table of symbol names. This is stored so we can clean up the atom.

error_names_atom: Atom.Index = .null,

/// Amount of functions in the `import` sections.

imported_functions_count: u32 = 0,

/// Amount of globals in the `import` section.

imported_globals_count: u32 = 0,

/// Symbol index representing the stack pointer. This will be set upon initializion

/// of a new `ZigObject`. Codegen will make calls into this to create relocations for

/// this symbol each time the stack pointer is moved.

stack_pointer_sym: Symbol.Index,

/// Debug information for the Zig module.

dwarf: ?Dwarf = null,

// Debug section atoms. These are only set when the current compilation

// unit contains Zig code. The lifetime of these atoms are extended

// until the end of the compiler's lifetime. Meaning they're not freed

// during `flush()` in incremental-mode.

debug_info_atom: ?Atom.Index = null,

debug_line_atom: ?Atom.Index = null,

debug_loc_atom: ?Atom.Index = null,

debug_ranges_atom: ?Atom.Index = null,

debug_abbrev_atom: ?Atom.Index = null,

debug_str_atom: ?Atom.Index = null,

debug_pubnames_atom: ?Atom.Index = null,

debug_pubtypes_atom: ?Atom.Index = null,

/// The index of the segment representing the custom '.debug_info' section.

debug_info_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_line' section.

debug_line_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_loc' section.

debug_loc_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_ranges' section.

debug_ranges_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_pubnames' section.

debug_pubnames_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_pubtypes' section.

debug_pubtypes_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_pubtypes' section.

debug_str_index: ?u32 = null,

/// The index of the segment representing the custom '.debug_pubtypes' section.

debug_abbrev_index: ?u32 = null,

 

const DeclInfo = struct {

atom: Atom.Index = .null,

exports: std.ArrayListUnmanaged(Symbol.Index) = .{},

 

fn @"export"(di: DeclInfo, zig_object: *const ZigObject, name: []const u8) ?Symbol.Index {

for (di.exports.items) |sym_index| {

const sym_name_index = zig_object.symbol(sym_index).name;

const sym_name = zig_object.string_table.getAssumeExists(sym_name_index);

if (std.mem.eql(u8, name, sym_name)) {

return sym_index;

}

}

return null;

}

 

fn appendExport(di: *DeclInfo, gpa: std.mem.Allocator, sym_index: Symbol.Index) !void {

return di.exports.append(gpa, sym_index);

}

 

fn deleteExport(di: *DeclInfo, sym_index: Symbol.Index) void {

for (di.exports.items, 0..) |idx, index| {

if (idx == sym_index) {

_ = di.exports.swapRemove(index);

return;

}

}

unreachable; // invalid sym_index

}

};

 

/// Initializes the `ZigObject` with initial symbols.

pub fn init(zig_object: *ZigObject, wasm_file: *Wasm) !void {

// Initialize an undefined global with the name __stack_pointer. Codegen will use

// this to generate relocations when moving the stack pointer. This symbol will be

// resolved automatically by the final linking stage.

try zig_object.createStackPointer(wasm_file);

 

// TODO: Initialize debug information when we reimplement Dwarf support.

}

 

fn createStackPointer(zig_object: *ZigObject, wasm_file: *Wasm) !void {

const gpa = wasm_file.base.comp.gpa;

const sym_index = try zig_object.getGlobalSymbol(gpa, "__stack_pointer");

const sym = zig_object.symbol(sym_index);

sym.index = zig_object.imported_globals_count;

sym.tag = .global;

const is_wasm32 = wasm_file.base.comp.root_mod.resolved_target.result.cpu.arch == .wasm32;

try zig_object.imports.putNoClobber(gpa, sym_index, .{

.name = sym.name,

.module_name = try zig_object.string_table.insert(gpa, wasm_file.host_name),

.kind = .{ .global = .{ .valtype = if (is_wasm32) .i32 else .i64, .mutable = true } },

});

zig_object.imported_globals_count += 1;

zig_object.stack_pointer_sym = sym_index;

}

 

fn symbol(zig_object: *const ZigObject, index: Symbol.Index) *Symbol {

return &zig_object.symbols.items[@intFromEnum(index)];

}

 

/// Frees and invalidates all memory of the incrementally compiled Zig module.

/// It is illegal behavior to access the `ZigObject` after calling `deinit`.

pub fn deinit(zig_object: *ZigObject, wasm_file: *Wasm) void {

const gpa = wasm_file.base.comp.gpa;

for (zig_object.segment_info.items) |segment_info| {

gpa.free(segment_info.name);

}

 

{

var it = zig_object.decls_map.valueIterator();

while (it.next()) |decl_info| {

const atom = wasm_file.getAtomPtr(decl_info.atom);

for (atom.locals.items) |local_index| {

const local_atom = wasm_file.getAtomPtr(local_index);

local_atom.deinit(gpa);

}

atom.deinit(gpa);

decl_info.exports.deinit(gpa);

}

}

{

for (zig_object.anon_decls.values()) |atom_index| {

const atom = wasm_file.getAtomPtr(atom_index);

for (atom.locals.items) |local_index| {

const local_atom = wasm_file.getAtomPtr(local_index);

local_atom.deinit(gpa);

}

atom.deinit(gpa);

}

}

if (zig_object.findGlobalSymbol("__zig_errors_len")) |sym_index| {

const atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index }).?;

wasm_file.getAtomPtr(atom_index).deinit(gpa);

}

if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = zig_object.error_table_symbol })) |atom_index| {

const atom = wasm_file.getAtomPtr(atom_index);

atom.deinit(gpa);

}

for (zig_object.synthetic_functions.items) |atom_index| {

const atom = wasm_file.getAtomPtr(atom_index);

atom.deinit(gpa);

}

zig_object.synthetic_functions.deinit(gpa);

for (zig_object.func_types.items) |*ty| {

ty.deinit(gpa);

}

if (zig_object.error_names_atom != .null) {

const atom = wasm_file.getAtomPtr(zig_object.error_names_atom);

atom.deinit(gpa);

}

zig_object.global_syms.deinit(gpa);

zig_object.func_types.deinit(gpa);

zig_object.atom_types.deinit(gpa);

zig_object.functions.deinit(gpa);

zig_object.imports.deinit(gpa);

zig_object.decls_map.deinit(gpa);

zig_object.anon_decls.deinit(gpa);

zig_object.symbols.deinit(gpa);

zig_object.symbols_free_list.deinit(gpa);

zig_object.segment_info.deinit(gpa);

zig_object.segment_free_list.deinit(gpa);

 

zig_object.string_table.deinit(gpa);

if (zig_object.dwarf) |*dwarf| {

dwarf.deinit();

}

gpa.free(zig_object.path);

zig_object.* = undefined;

}

 

/// Allocates a new symbol and returns its index.

/// Will re-use slots when a symbol was freed at an earlier stage.

pub fn allocateSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator) !Symbol.Index {

try zig_object.symbols.ensureUnusedCapacity(gpa, 1);

const sym: Symbol = .{

.name = std.math.maxInt(u32), // will be set after updateDecl as well as during atom creation for decls

.flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),

.tag = .undefined, // will be set after updateDecl

.index = std.math.maxInt(u32), // will be set during atom parsing

.virtual_address = std.math.maxInt(u32), // will be set during atom allocation

};

if (zig_object.symbols_free_list.popOrNull()) |index| {

zig_object.symbols.items[@intFromEnum(index)] = sym;

return index;

}

const index: Symbol.Index = @enumFromInt(zig_object.symbols.items.len);

zig_object.symbols.appendAssumeCapacity(sym);

return index;

}

 

// Generate code for the Decl, storing it in memory to be later written to

// the file on flush().

pub fn updateDecl(

zig_object: *ZigObject,

wasm_file: *Wasm,

mod: *Module,

decl_index: InternPool.DeclIndex,

) !void {

const decl = mod.declPtr(decl_index);

if (decl.val.getFunction(mod)) |_| {

return;

} else if (decl.val.getExternFunc(mod)) |_| {

return;

}

 

const gpa = wasm_file.base.comp.gpa;

const atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, decl_index);

const atom = wasm_file.getAtomPtr(atom_index);

atom.clear();

 

if (decl.isExtern(mod)) {

const variable = decl.getOwnedVariable(mod).?;

const name = mod.intern_pool.stringToSlice(decl.name);

const lib_name = mod.intern_pool.stringToSliceUnwrap(variable.lib_name);

return zig_object.addOrUpdateImport(wasm_file, name, atom.sym_index, lib_name, null);

}

const val = if (decl.val.getVariable(mod)) |variable| Value.fromInterned(variable.init) else decl.val;

 

var code_writer = std.ArrayList(u8).init(gpa);

defer code_writer.deinit();

 

const res = try codegen.generateSymbol(

&wasm_file.base,

decl.srcLoc(mod),

.{ .ty = decl.ty, .val = val },

&code_writer,

.none,

.{ .parent_atom_index = @intFromEnum(atom.sym_index) },

);

 

const code = switch (res) {

.ok => code_writer.items,

.fail => |em| {

decl.analysis = .codegen_failure;

try mod.failed_decls.put(mod.gpa, decl_index, em);

return;

},

};

 

return zig_object.finishUpdateDecl(wasm_file, decl_index, code);

}

 

pub fn updateFunc(

zig_object: *ZigObject,

wasm_file: *Wasm,

mod: *Module,

func_index: InternPool.Index,

air: Air,

liveness: Liveness,

) !void {

const gpa = wasm_file.base.comp.gpa;

const func = mod.funcInfo(func_index);

const decl_index = func.owner_decl;

const decl = mod.declPtr(decl_index);

const atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, decl_index);

const atom = wasm_file.getAtomPtr(atom_index);

atom.clear();

 

var code_writer = std.ArrayList(u8).init(gpa);

defer code_writer.deinit();

const result = try codegen.generateFunction(

&wasm_file.base,

decl.srcLoc(mod),

func_index,

air,

liveness,

&code_writer,

.none,

);

 

const code = switch (result) {

.ok => code_writer.items,

.fail => |em| {

decl.analysis = .codegen_failure;

try mod.failed_decls.put(mod.gpa, decl_index, em);

return;

},

};

 

return zig_object.finishUpdateDecl(wasm_file, decl_index, code);

}

 

fn finishUpdateDecl(

zig_object: *ZigObject,

wasm_file: *Wasm,

decl_index: InternPool.DeclIndex,

code: []const u8,

) !void {

const gpa = wasm_file.base.comp.gpa;

const mod = wasm_file.base.comp.module.?;

const decl = mod.declPtr(decl_index);

const decl_info = zig_object.decls_map.get(decl_index).?;

const atom_index = decl_info.atom;

const atom = wasm_file.getAtomPtr(atom_index);

const sym = zig_object.symbol(atom.sym_index);

const full_name = mod.intern_pool.stringToSlice(try decl.fullyQualifiedName(mod));

sym.name = try zig_object.string_table.insert(gpa, full_name);

try atom.code.appendSlice(gpa, code);

atom.size = @intCast(code.len);

 

switch (decl.ty.zigTypeTag(mod)) {

.Fn => {

sym.index = try zig_object.appendFunction(gpa, .{ .type_index = zig_object.atom_types.get(atom_index).? });

sym.tag = .function;

},

else => {

const segment_name: []const u8 = if (decl.getOwnedVariable(mod)) |variable| name: {

if (variable.is_const) {

break :name ".rodata.";

} else if (Value.fromInterned(variable.init).isUndefDeep(mod)) {

const decl_namespace = mod.namespacePtr(decl.src_namespace);

const optimize_mode = decl_namespace.file_scope.mod.optimize_mode;

const is_initialized = switch (optimize_mode) {

.Debug, .ReleaseSafe => true,

.ReleaseFast, .ReleaseSmall => false,

};

if (is_initialized) {

break :name ".data.";

}

break :name ".bss.";

}

// when the decl is all zeroes, we store the atom in the bss segment,

// in all other cases it will be in the data segment.

for (atom.code.items) |byte| {

if (byte != 0) break :name ".data.";

}

break :name ".bss.";

} else ".rodata.";

if ((wasm_file.base.isObject() or wasm_file.base.comp.config.import_memory) and

std.mem.startsWith(u8, segment_name, ".bss"))

{

@memset(atom.code.items, 0);

}

// Will be freed upon freeing of decl or after cleanup of Wasm binary.

const full_segment_name = try std.mem.concat(gpa, u8, &.{

segment_name,

full_name,

});

errdefer gpa.free(full_segment_name);

sym.tag = .data;

sym.index = try zig_object.createDataSegment(gpa, full_segment_name, decl.alignment);

},

}

if (code.len == 0) return;

atom.alignment = decl.getAlignment(mod);

}

 

/// Creates and initializes a new segment in the 'Data' section.

/// Reuses free slots in the list of segments and returns the index.

fn createDataSegment(

zig_object: *ZigObject,

gpa: std.mem.Allocator,

name: []const u8,

alignment: InternPool.Alignment,

) !u32 {

const segment_index: u32 = if (zig_object.segment_free_list.popOrNull()) |index|

index

else index: {

const idx: u32 = @intCast(zig_object.segment_info.items.len);

_ = try zig_object.segment_info.addOne(gpa);

break :index idx;

};

zig_object.segment_info.items[segment_index] = .{

.alignment = alignment,

.flags = 0,

.name = name,

};

return segment_index;

}

 

/// For a given `InternPool.DeclIndex` returns its corresponding `Atom.Index`.

/// When the index was not found, a new `Atom` will be created, and its index will be returned.

/// The newly created Atom is empty with default fields as specified by `Atom.empty`.

pub fn getOrCreateAtomForDecl(zig_object: *ZigObject, wasm_file: *Wasm, decl_index: InternPool.DeclIndex) !Atom.Index {

const gpa = wasm_file.base.comp.gpa;

const gop = try zig_object.decls_map.getOrPut(gpa, decl_index);

if (!gop.found_existing) {

const sym_index = try zig_object.allocateSymbol(gpa);

gop.value_ptr.* = .{ .atom = try wasm_file.createAtom(sym_index, zig_object.index) };

const mod = wasm_file.base.comp.module.?;

const decl = mod.declPtr(decl_index);

const full_name = mod.intern_pool.stringToSlice(try decl.fullyQualifiedName(mod));

const sym = zig_object.symbol(sym_index);

sym.name = try zig_object.string_table.insert(gpa, full_name);

}

return gop.value_ptr.atom;

}

 

pub fn lowerAnonDecl(

zig_object: *ZigObject,

wasm_file: *Wasm,

decl_val: InternPool.Index,

explicit_alignment: InternPool.Alignment,

src_loc: Module.SrcLoc,

) !codegen.Result {

const gpa = wasm_file.base.comp.gpa;

const gop = try zig_object.anon_decls.getOrPut(gpa, decl_val);

if (!gop.found_existing) {

const mod = wasm_file.base.comp.module.?;

const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));

const tv: TypedValue = .{ .ty = ty, .val = Value.fromInterned(decl_val) };

var name_buf: [32]u8 = undefined;

const name = std.fmt.bufPrint(&name_buf, "__anon_{d}", .{

@intFromEnum(decl_val),

}) catch unreachable;

 

switch (try zig_object.lowerConst(wasm_file, name, tv, src_loc)) {

.ok => |atom_index| zig_object.anon_decls.values()[gop.index] = atom_index,

.fail => |em| return .{ .fail = em },

}

}

 

const atom = wasm_file.getAtomPtr(zig_object.anon_decls.values()[gop.index]);

atom.alignment = switch (atom.alignment) {

.none => explicit_alignment,

else => switch (explicit_alignment) {

.none => atom.alignment,

else => atom.alignment.maxStrict(explicit_alignment),

},

};

return .ok;

}

 

/// Lowers a constant typed value to a local symbol and atom.

/// Returns the symbol index of the local

/// The given `decl` is the parent decl whom owns the constant.

pub fn lowerUnnamedConst(zig_object: *ZigObject, wasm_file: *Wasm, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

const gpa = wasm_file.base.comp.gpa;

const mod = wasm_file.base.comp.module.?;

std.debug.assert(tv.ty.zigTypeTag(mod) != .Fn); // cannot create local symbols for functions

const decl = mod.declPtr(decl_index);

 

const parent_atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, decl_index);

const parent_atom = wasm_file.getAtom(parent_atom_index);

const local_index = parent_atom.locals.items.len;

const fqn = mod.intern_pool.stringToSlice(try decl.fullyQualifiedName(mod));

const name = try std.fmt.allocPrintZ(gpa, "__unnamed_{s}_{d}", .{

fqn, local_index,

});

defer gpa.free(name);

 

switch (try zig_object.lowerConst(wasm_file, name, tv, decl.srcLoc(mod))) {

.ok => |atom_index| {

try wasm_file.getAtomPtr(parent_atom_index).locals.append(gpa, atom_index);

return @intFromEnum(wasm_file.getAtom(atom_index).sym_index);

},

.fail => |em| {

decl.analysis = .codegen_failure;

try mod.failed_decls.put(mod.gpa, decl_index, em);

return error.CodegenFail;

},

}

}

 

const LowerConstResult = union(enum) {

ok: Atom.Index,

fail: *Module.ErrorMsg,

};

 

fn lowerConst(zig_object: *ZigObject, wasm_file: *Wasm, name: []const u8, tv: TypedValue, src_loc: Module.SrcLoc) !LowerConstResult {

const gpa = wasm_file.base.comp.gpa;

const mod = wasm_file.base.comp.module.?;

 

// Create and initialize a new local symbol and atom

const sym_index = try zig_object.allocateSymbol(gpa);

const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);

var value_bytes = std.ArrayList(u8).init(gpa);

defer value_bytes.deinit();

 

const code = code: {

const atom = wasm_file.getAtomPtr(atom_index);

atom.alignment = tv.ty.abiAlignment(mod);

const segment_name = try std.mem.concat(gpa, u8, &.{ ".rodata.", name });

errdefer gpa.free(segment_name);

zig_object.symbol(sym_index).* = .{

.name = try zig_object.string_table.insert(gpa, name),

.flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),

.tag = .data,

.index = try zig_object.createDataSegment(

gpa,

segment_name,

tv.ty.abiAlignment(mod),

),

.virtual_address = undefined,

};

 

const result = try codegen.generateSymbol(

&wasm_file.base,

src_loc,

tv,

&value_bytes,

.none,

.{

.parent_atom_index = @intFromEnum(atom.sym_index),

.addend = null,

},

);

break :code switch (result) {

.ok => value_bytes.items,

.fail => |em| {

return .{ .fail = em };

},

};

};

 

const atom = wasm_file.getAtomPtr(atom_index);

atom.size = @intCast(code.len);

try atom.code.appendSlice(gpa, code);

return .{ .ok = atom_index };

}

 

/// Returns the symbol index of the error name table.

///

/// When the symbol does not yet exist, it will create a new one instead.

pub fn getErrorTableSymbol(zig_object: *ZigObject, wasm_file: *Wasm) !Symbol.Index {

if (zig_object.error_table_symbol != .null) {

return zig_object.error_table_symbol;

}

 

// no error was referenced yet, so create a new symbol and atom for it

// and then return said symbol's index. The final table will be populated

// during `flush` when we know all possible error names.

const gpa = wasm_file.base.comp.gpa;

const sym_index = try zig_object.allocateSymbol(gpa);

const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);

const atom = wasm_file.getAtomPtr(atom_index);

const slice_ty = Type.slice_const_u8_sentinel_0;

const mod = wasm_file.base.comp.module.?;

atom.alignment = slice_ty.abiAlignment(mod);

 

const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_name_table");

const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_name_table");

const sym = zig_object.symbol(sym_index);

sym.* = .{

.name = sym_name,

.tag = .data,

.flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),

.index = try zig_object.createDataSegment(gpa, segment_name, atom.alignment),

.virtual_address = undefined,

};

 

log.debug("Error name table was created with symbol index: ({d})", .{@intFromEnum(sym_index)});

zig_object.error_table_symbol = sym_index;

return sym_index;

}

 

/// Populates the error name table, when `error_table_symbol` is not null.

///

/// This creates a table that consists of pointers and length to each error name.

/// The table is what is being pointed to within the runtime bodies that are generated.

fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm) !void {

if (zig_object.error_table_symbol == .null) return;

const gpa = wasm_file.base.comp.gpa;

const atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = zig_object.error_table_symbol }).?;

 

// Rather than creating a symbol for each individual error name,

// we create a symbol for the entire region of error names. We then calculate

// the pointers into the list using addends which are appended to the relocation.

const names_sym_index = try zig_object.allocateSymbol(gpa);

const names_atom_index = try wasm_file.createAtom(names_sym_index, zig_object.index);

const names_atom = wasm_file.getAtomPtr(names_atom_index);

names_atom.alignment = .@"1";

const sym_name = try zig_object.string_table.insert(gpa, "__zig_err_names");

const segment_name = try gpa.dupe(u8, ".rodata.__zig_err_names");

const names_symbol = zig_object.symbol(names_sym_index);

names_symbol.* = .{

.name = sym_name,

.tag = .data,

.flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),

.index = try zig_object.createDataSegment(gpa, segment_name, names_atom.alignment),

.virtual_address = undefined,

};

 

log.debug("Populating error names", .{});

 

// Addend for each relocation to the table

var addend: u32 = 0;

const mod = wasm_file.base.comp.module.?;

for (mod.global_error_set.keys()) |error_name_nts| {

const atom = wasm_file.getAtomPtr(atom_index);

 

const error_name = mod.intern_pool.stringToSlice(error_name_nts);

const len: u32 = @intCast(error_name.len + 1); // names are 0-terminated

 

const slice_ty = Type.slice_const_u8_sentinel_0;

const offset = @as(u32, @intCast(atom.code.items.len));

// first we create the data for the slice of the name

try atom.code.appendNTimes(gpa, 0, 4); // ptr to name, will be relocated

try atom.code.writer(gpa).writeInt(u32, len - 1, .little);

// create relocation to the error name

try atom.relocs.append(gpa, .{

.index = @intFromEnum(names_atom.sym_index),

.relocation_type = .R_WASM_MEMORY_ADDR_I32,

.offset = offset,

.addend = @intCast(addend),

});

atom.size += @intCast(slice_ty.abiSize(mod));

addend += len;

 

// as we updated the error name table, we now store the actual name within the names atom

try names_atom.code.ensureUnusedCapacity(gpa, len);

names_atom.code.appendSliceAssumeCapacity(error_name);

names_atom.code.appendAssumeCapacity(0);

 

log.debug("Populated error name: '{s}'", .{error_name});

}

names_atom.size = addend;

zig_object.error_names_atom = names_atom_index;

}

 

/// Either creates a new import, or updates one if existing.

/// When `type_index` is non-null, we assume an external function.

/// In all other cases, a data-symbol will be created instead.

pub fn addOrUpdateImport(

zig_object: *ZigObject,

wasm_file: *Wasm,

/// Name of the import

name: []const u8,

/// Symbol index that is external

symbol_index: Symbol.Index,

/// Optional library name (i.e. `extern "c" fn foo() void`

lib_name: ?[:0]const u8,

/// The index of the type that represents the function signature

/// when the extern is a function. When this is null, a data-symbol

/// is asserted instead.

type_index: ?u32,

) !void {

const gpa = wasm_file.base.comp.gpa;

std.debug.assert(symbol_index != .null);

// For the import name, we use the decl's name, rather than the fully qualified name

// Also mangle the name when the lib name is set and not equal to "C" so imports with the same

// name but different module can be resolved correctly.

const mangle_name = lib_name != null and

!std.mem.eql(u8, lib_name.?, "c");

const full_name = if (mangle_name) full_name: {

break :full_name try std.fmt.allocPrint(gpa, "{s}|{s}", .{ name, lib_name.? });

} else name;

defer if (mangle_name) gpa.free(full_name);

 

const decl_name_index = try zig_object.string_table.insert(gpa, full_name);

const sym: *Symbol = &zig_object.symbols.items[@intFromEnum(symbol_index)];

sym.setUndefined(true);

sym.setGlobal(true);

sym.name = decl_name_index;

if (mangle_name) {

// we specified a specific name for the symbol that does not match the import name

sym.setFlag(.WASM_SYM_EXPLICIT_NAME);

}

 

if (type_index) |ty_index| {

const gop = try zig_object.imports.getOrPut(gpa, symbol_index);

const module_name = if (lib_name) |l_name| l_name else wasm_file.host_name;

if (!gop.found_existing) {

zig_object.imported_functions_count += 1;

}

gop.value_ptr.* = .{

.module_name = try zig_object.string_table.insert(gpa, module_name),

.name = try zig_object.string_table.insert(gpa, name),

.kind = .{ .function = ty_index },

};

sym.tag = .function;

} else {

sym.tag = .data;

}

}

 

/// Returns the symbol index from a symbol of which its flag is set global,

/// such as an exported or imported symbol.

/// If the symbol does not yet exist, creates a new one symbol instead

/// and then returns the index to it.

pub fn getGlobalSymbol(zig_object: *ZigObject, gpa: std.mem.Allocator, name: []const u8) !Symbol.Index {

const name_index = try zig_object.string_table.insert(gpa, name);

const gop = try zig_object.global_syms.getOrPut(gpa, name_index);

if (gop.found_existing) {

return gop.value_ptr.*;

}

 

var sym: Symbol = .{

.name = name_index,

.flags = 0,

.index = undefined, // index to type will be set after merging symbols

.tag = .function,

.virtual_address = std.math.maxInt(u32),

};

sym.setGlobal(true);

sym.setUndefined(true);

 

const sym_index = if (zig_object.symbols_free_list.popOrNull()) |index| index else blk: {

const index: Symbol.Index = @enumFromInt(zig_object.symbols.items.len);

try zig_object.symbols.ensureUnusedCapacity(gpa, 1);

zig_object.symbols.items.len += 1;

break :blk index;

};

zig_object.symbol(sym_index).* = sym;

gop.value_ptr.* = sym_index;

return sym_index;

}

 

/// For a given decl, find the given symbol index's atom, and create a relocation for the type.

/// Returns the given pointer address

pub fn getDeclVAddr(

zig_object: *ZigObject,

wasm_file: *Wasm,

decl_index: InternPool.DeclIndex,

reloc_info: link.File.RelocInfo,

) !u64 {

const target = wasm_file.base.comp.root_mod.resolved_target.result;

const gpa = wasm_file.base.comp.gpa;

const mod = wasm_file.base.comp.module.?;

const decl = mod.declPtr(decl_index);

 

const target_atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, decl_index);

const target_symbol_index = @intFromEnum(wasm_file.getAtom(target_atom_index).sym_index);

 

std.debug.assert(reloc_info.parent_atom_index != 0);

const atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = @enumFromInt(reloc_info.parent_atom_index) }).?;

const atom = wasm_file.getAtomPtr(atom_index);

const is_wasm32 = target.cpu.arch == .wasm32;

if (decl.ty.zigTypeTag(mod) == .Fn) {

std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations

try atom.relocs.append(gpa, .{

.index = target_symbol_index,

.offset = @intCast(reloc_info.offset),

.relocation_type = if (is_wasm32) .R_WASM_TABLE_INDEX_I32 else .R_WASM_TABLE_INDEX_I64,

});

} else {

try atom.relocs.append(gpa, .{

.index = target_symbol_index,

.offset = @intCast(reloc_info.offset),

.relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_I32 else .R_WASM_MEMORY_ADDR_I64,

.addend = @intCast(reloc_info.addend),

});

}

 

// we do not know the final address at this point,

// as atom allocation will determine the address and relocations

// will calculate and rewrite this. Therefore, we simply return the symbol index

// that was targeted.

return target_symbol_index;

}

 

pub fn getAnonDeclVAddr(

zig_object: *ZigObject,

wasm_file: *Wasm,

decl_val: InternPool.Index,

reloc_info: link.File.RelocInfo,

) !u64 {

const gpa = wasm_file.base.comp.gpa;

const target = wasm_file.base.comp.root_mod.resolved_target.result;

const atom_index = zig_object.anon_decls.get(decl_val).?;

const target_symbol_index = @intFromEnum(wasm_file.getAtom(atom_index).sym_index);

 

const parent_atom_index = wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = @enumFromInt(reloc_info.parent_atom_index) }).?;

const parent_atom = wasm_file.getAtomPtr(parent_atom_index);

const is_wasm32 = target.cpu.arch == .wasm32;

const mod = wasm_file.base.comp.module.?;

const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));

if (ty.zigTypeTag(mod) == .Fn) {

std.debug.assert(reloc_info.addend == 0); // addend not allowed for function relocations

try parent_atom.relocs.append(gpa, .{

.index = target_symbol_index,

.offset = @intCast(reloc_info.offset),

.relocation_type = if (is_wasm32) .R_WASM_TABLE_INDEX_I32 else .R_WASM_TABLE_INDEX_I64,

});

} else {

try parent_atom.relocs.append(gpa, .{

.index = target_symbol_index,

.offset = @intCast(reloc_info.offset),

.relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_I32 else .R_WASM_MEMORY_ADDR_I64,

.addend = @intCast(reloc_info.addend),

});

}

 

// we do not know the final address at this point,

// as atom allocation will determine the address and relocations

// will calculate and rewrite this. Therefore, we simply return the symbol index

// that was targeted.

return target_symbol_index;

}

 

pub fn deleteDeclExport(

zig_object: *ZigObject,

wasm_file: *Wasm,

decl_index: InternPool.DeclIndex,

name: InternPool.NullTerminatedString,

) void {

const mod = wasm_file.base.comp.module.?;

const decl_info = zig_object.decls_map.getPtr(decl_index) orelse return;

const export_name = mod.intern_pool.stringToSlice(name);

if (decl_info.@"export"(zig_object, export_name)) |sym_index| {

const sym = zig_object.symbol(sym_index);

decl_info.deleteExport(sym_index);

std.debug.assert(zig_object.global_syms.remove(sym.name));

std.debug.assert(wasm_file.symbol_atom.remove(.{ .file = zig_object.index, .index = sym_index }));

zig_object.symbols_free_list.append(wasm_file.base.comp.gpa, sym_index) catch {};

sym.tag = .dead;

}

}

 

pub fn updateExports(

zig_object: *ZigObject,

wasm_file: *Wasm,

mod: *Module,

exported: Module.Exported,

exports: []const *Module.Export,

) !void {

const decl_index = switch (exported) {

.decl_index => |i| i,

.value => |val| {

_ = val;

@panic("TODO: implement Wasm linker code for exporting a constant value");

},

};

const decl = mod.declPtr(decl_index);

const atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, decl_index);

const decl_info = zig_object.decls_map.getPtr(decl_index).?;

const atom = wasm_file.getAtom(atom_index);

const atom_sym = atom.symbolLoc().getSymbol(wasm_file).*;

const gpa = mod.gpa;

log.debug("Updating exports for decl '{s}'", .{mod.intern_pool.stringToSlice(decl.name)});

 

for (exports) |exp| {

if (mod.intern_pool.stringToSliceUnwrap(exp.opts.section)) |section| {

try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(

gpa,

decl.srcLoc(mod),

"Unimplemented: ExportOptions.section '{s}'",

.{section},

));

continue;

}

 

const export_string = mod.intern_pool.stringToSlice(exp.opts.name);

const sym_index = if (decl_info.@"export"(zig_object, export_string)) |idx|

idx

else index: {

const sym_index = try zig_object.allocateSymbol(gpa);

try decl_info.appendExport(gpa, sym_index);

break :index sym_index;

};

 

const export_name = try zig_object.string_table.insert(gpa, export_string);

const sym = zig_object.symbol(sym_index);

sym.setGlobal(true);

sym.setUndefined(false);

sym.index = atom_sym.index;

sym.tag = atom_sym.tag;

sym.name = export_name;

 

switch (exp.opts.linkage) {

.Internal => {

sym.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);

},

.Weak => {

sym.setFlag(.WASM_SYM_BINDING_WEAK);

},

.Strong => {}, // symbols are strong by default

.LinkOnce => {

try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(

gpa,

decl.srcLoc(mod),

"Unimplemented: LinkOnce",

.{},

));

continue;

},

}

if (exp.opts.visibility == .hidden) {

sym.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);

}

log.debug(" with name '{s}' - {}", .{ export_string, sym });

try zig_object.global_syms.put(gpa, export_name, sym_index);

try wasm_file.symbol_atom.put(gpa, .{ .file = zig_object.index, .index = sym_index }, atom_index);

}

}

 

pub fn freeDecl(zig_object: *ZigObject, wasm_file: *Wasm, decl_index: InternPool.DeclIndex) void {

const gpa = wasm_file.base.comp.gpa;

const mod = wasm_file.base.comp.module.?;

const decl = mod.declPtr(decl_index);

const decl_info = zig_object.decls_map.getPtr(decl_index).?;

const atom_index = decl_info.atom;

const atom = wasm_file.getAtomPtr(atom_index);

zig_object.symbols_free_list.append(gpa, atom.sym_index) catch {};

for (decl_info.exports.items) |exp_sym_index| {

const exp_sym = zig_object.symbol(exp_sym_index);

exp_sym.tag = .dead;

zig_object.symbols_free_list.append(exp_sym_index) catch {};

}

decl_info.exports.deinit(gpa);

std.debug.assert(zig_object.decls_map.remove(decl_index));

const sym = &zig_object.symbols.items[atom.sym_index];

for (atom.locals.items) |local_atom_index| {

const local_atom = wasm_file.getAtom(local_atom_index);

const local_symbol = &zig_object.symbols.items[local_atom.sym_index];

std.debug.assert(local_symbol.tag == .data);

zig_object.symbols_free_list.append(gpa, local_atom.sym_index) catch {};

std.debug.assert(wasm_file.symbol_atom.remove(local_atom.symbolLoc()));

local_symbol.tag = .dead; // also for any local symbol

const segment = &zig_object.segment_info.items[local_atom.sym_index];

gpa.free(segment.name);

segment.name = &.{}; // Ensure no accidental double free

}

 

if (decl.isExtern(mod)) {

std.debug.assert(zig_object.imports.remove(atom.sym_index));

}

std.debug.assert(wasm_file.symbol_atom.remove(atom.symbolLoc()));

 

// if (wasm.dwarf) |*dwarf| {

// dwarf.freeDecl(decl_index);

// }

 

atom.prev = null;

sym.tag = .dead;

if (sym.isGlobal()) {

std.debug.assert(zig_object.global_syms.remove(atom.sym_index));

}

switch (decl.ty.zigTypeTag(mod)) {

.Fn => {

zig_object.functions_free_list.append(gpa, sym.index) catch {};

std.debug.assert(zig_object.atom_types.remove(atom_index));

},

else => {

zig_object.segment_free_list.append(gpa, sym.index) catch {};

const segment = &zig_object.segment_info.items[sym.index];

gpa.free(segment.name);

segment.name = &.{}; // Prevent accidental double free

},

}

}

 

fn getTypeIndex(zig_object: *const ZigObject, func_type: std.wasm.Type) ?u32 {

var index: u32 = 0;

while (index < zig_object.func_types.items.len) : (index += 1) {

if (zig_object.func_types.items[index].eql(func_type)) return index;

}

return null;

}

 

/// Searches for a matching function signature. When no matching signature is found,

/// a new entry will be made. The value returned is the index of the type within `wasm.func_types`.

pub fn putOrGetFuncType(zig_object: *ZigObject, gpa: std.mem.Allocator, func_type: std.wasm.Type) !u32 {

if (zig_object.getTypeIndex(func_type)) |index| {

return index;

}

 

// functype does not exist.

const index: u32 = @intCast(zig_object.func_types.items.len);

const params = try gpa.dupe(std.wasm.Valtype, func_type.params);

errdefer gpa.free(params);

const returns = try gpa.dupe(std.wasm.Valtype, func_type.returns);

errdefer gpa.free(returns);

try zig_object.func_types.append(gpa, .{

.params = params,

.returns = returns,

});

return index;

}

 

/// Generates an atom containing the global error set' size.

/// This will only be generated if the symbol exists.

fn setupErrorsLen(zig_object: *ZigObject, wasm_file: *Wasm) !void {

const gpa = wasm_file.base.comp.gpa;

const sym_index = zig_object.findGlobalSymbol("__zig_errors_len") orelse return;

 

const errors_len = wasm_file.base.comp.module.?.global_error_set.count();

// overwrite existing atom if it already exists (maybe the error set has increased)

// if not, allcoate a new atom.

const atom_index = if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index })) |index| blk: {

const atom = wasm_file.getAtomPtr(index);

atom.prev = .null;

atom.deinit(gpa);

break :blk index;

} else idx: {

// We found a call to __zig_errors_len so make the symbol a local symbol

// and define it, so the final binary or resulting object file will not attempt

// to resolve it.

const sym = zig_object.symbol(sym_index);

sym.setGlobal(false);

sym.setUndefined(false);

sym.tag = .data;

const segment_name = try gpa.dupe(u8, ".rodata.__zig_errors_len");

sym.index = try zig_object.createDataSegment(gpa, segment_name, .@"2");

break :idx try wasm_file.createAtom(sym_index, zig_object.index);

};

 

const atom = wasm_file.getAtomPtr(atom_index);

atom.code.clearRetainingCapacity();

atom.sym_index = sym_index;

atom.size = 2;

atom.alignment = .@"2";

try atom.code.writer(gpa).writeInt(u16, @intCast(errors_len), .little);

}

 

fn findGlobalSymbol(zig_object: *ZigObject, name: []const u8) ?Symbol.Index {

const offset = zig_object.string_table.getOffset(name) orelse return null;

return zig_object.global_syms.get(offset);

}

 

/// Initializes symbols and atoms for the debug sections

/// Initialization is only done when compiling Zig code.

/// When Zig is invoked as a linker instead, the atoms

/// and symbols come from the object files instead.

pub fn initDebugSections(zig_object: *ZigObject) !void {

if (zig_object.dwarf == null) return; // not compiling Zig code, so no need to pre-initialize debug sections

std.debug.assert(zig_object.debug_info_index == null);

// this will create an Atom and set the index for us.

zig_object.debug_info_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_info_index, ".debug_info");

zig_object.debug_line_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_line_index, ".debug_line");

zig_object.debug_loc_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_loc_index, ".debug_loc");

zig_object.debug_abbrev_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_abbrev_index, ".debug_abbrev");

zig_object.debug_ranges_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_ranges_index, ".debug_ranges");

zig_object.debug_str_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_str_index, ".debug_str");

zig_object.debug_pubnames_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_pubnames_index, ".debug_pubnames");

zig_object.debug_pubtypes_atom = try zig_object.createDebugSectionForIndex(&zig_object.debug_pubtypes_index, ".debug_pubtypes");

}

 

/// From a given index variable, creates a new debug section.

/// This initializes the index, appends a new segment,

/// and finally, creates a managed `Atom`.

pub fn createDebugSectionForIndex(zig_object: *ZigObject, wasm_file: *Wasm, index: *?u32, name: []const u8) !Atom.Index {

const gpa = wasm_file.base.comp.gpa;

const new_index: u32 = @intCast(zig_object.segments.items.len);

index.* = new_index;

try zig_object.appendDummySegment();

 

const sym_index = try zig_object.allocateSymbol(gpa);

const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);

const atom = wasm_file.getAtomPtr(atom_index);

zig_object.symbols.items[sym_index] = .{

.tag = .section,

.name = try zig_object.string_table.put(gpa, name),

.index = 0,

.flags = @intFromEnum(Symbol.Flag.WASM_SYM_BINDING_LOCAL),

};

 

atom.alignment = .@"1"; // debug sections are always 1-byte-aligned

return atom_index;

}

 

pub fn updateDeclLineNumber(zig_object: *ZigObject, mod: *Module, decl_index: InternPool.DeclIndex) !void {

if (zig_object.dwarf) |*dw| {

const decl = mod.declPtr(decl_index);

const decl_name = mod.intern_pool.stringToSlice(try decl.fullyQualifiedName(mod));

 

log.debug("updateDeclLineNumber {s}{*}", .{ decl_name, decl });

try dw.updateDeclLineNumber(mod, decl_index);

}

}

 

/// Allocates debug atoms into their respective debug sections

/// to merge them with maybe-existing debug atoms from object files.

fn allocateDebugAtoms(zig_object: *ZigObject) !void {

if (zig_object.dwarf == null) return;

 

const allocAtom = struct {

fn f(ctx: *ZigObject, maybe_index: *?u32, atom_index: Atom.Index) !void {

const index = maybe_index.* orelse idx: {

const index = @as(u32, @intCast(ctx.segments.items.len));

try ctx.appendDummySegment();

maybe_index.* = index;

break :idx index;

};

const atom = ctx.getAtomPtr(atom_index);

atom.size = @as(u32, @intCast(atom.code.items.len));

ctx.symbols.items[atom.sym_index].index = index;

try ctx.appendAtomAtIndex(index, atom_index);

}

}.f;

 

try allocAtom(zig_object, &zig_object.debug_info_index, zig_object.debug_info_atom.?);

try allocAtom(zig_object, &zig_object.debug_line_index, zig_object.debug_line_atom.?);

try allocAtom(zig_object, &zig_object.debug_loc_index, zig_object.debug_loc_atom.?);

try allocAtom(zig_object, &zig_object.debug_str_index, zig_object.debug_str_atom.?);

try allocAtom(zig_object, &zig_object.debug_ranges_index, zig_object.debug_ranges_atom.?);

try allocAtom(zig_object, &zig_object.debug_abbrev_index, zig_object.debug_abbrev_atom.?);

try allocAtom(zig_object, &zig_object.debug_pubnames_index, zig_object.debug_pubnames_atom.?);

try allocAtom(zig_object, &zig_object.debug_pubtypes_index, zig_object.debug_pubtypes_atom.?);

}

 

/// For the given `decl_index`, stores the corresponding type representing the function signature.

/// Asserts declaration has an associated `Atom`.

/// Returns the index into the list of types.

pub fn storeDeclType(zig_object: *ZigObject, gpa: std.mem.Allocator, decl_index: InternPool.DeclIndex, func_type: std.wasm.Type) !u32 {

const decl_info = zig_object.decls_map.get(decl_index).?;

const index = try zig_object.putOrGetFuncType(gpa, func_type);

try zig_object.atom_types.put(gpa, decl_info.atom, index);

return index;

}

 

/// The symbols in ZigObject are already represented by an atom as we need to store its data.

/// So rather than creating a new Atom and returning its index, we use this oppertunity to scan

/// its relocations and create any GOT symbols or function table indexes it may require.

pub fn parseSymbolIntoAtom(zig_object: *ZigObject, wasm_file: *Wasm, index: Symbol.Index) !Atom.Index {

const gpa = wasm_file.base.comp.gpa;

const loc: Wasm.SymbolLoc = .{ .file = zig_object.index, .index = index };

const atom_index = wasm_file.symbol_atom.get(loc).?;

const final_index = try wasm_file.getMatchingSegment(zig_object.index, index);

try wasm_file.appendAtomAtIndex(final_index, atom_index);

const atom = wasm_file.getAtom(atom_index);

for (atom.relocs.items) |reloc| {

const reloc_index: Symbol.Index = @enumFromInt(reloc.index);

switch (reloc.relocation_type) {

.R_WASM_TABLE_INDEX_I32,

.R_WASM_TABLE_INDEX_I64,

.R_WASM_TABLE_INDEX_SLEB,

.R_WASM_TABLE_INDEX_SLEB64,

=> {

try wasm_file.function_table.put(gpa, .{

.file = zig_object.index,

.index = reloc_index,

}, 0);

},

.R_WASM_GLOBAL_INDEX_I32,

.R_WASM_GLOBAL_INDEX_LEB,

=> {

const sym = zig_object.symbol(reloc_index);

if (sym.tag != .global) {

try wasm_file.got_symbols.append(gpa, .{

.file = zig_object.index,

.index = reloc_index,

});

}

},

else => {},

}

}

return atom_index;

}

 

/// Creates a new Wasm function with a given symbol name and body.

/// Returns the symbol index of the new function.

pub fn createFunction(

zig_object: *ZigObject,

wasm_file: *Wasm,

symbol_name: []const u8,

func_ty: std.wasm.Type,

function_body: *std.ArrayList(u8),

relocations: *std.ArrayList(types.Relocation),

) !Symbol.Index {

const gpa = wasm_file.base.comp.gpa;

const sym_index = try zig_object.allocateSymbol(gpa);

const sym = zig_object.symbol(sym_index);

sym.tag = .function;

sym.name = try zig_object.string_table.insert(gpa, symbol_name);

const type_index = try zig_object.putOrGetFuncType(gpa, func_ty);

sym.index = try zig_object.appendFunction(gpa, .{ .type_index = type_index });

 

const atom_index = try wasm_file.createAtom(sym_index, zig_object.index);

const atom = wasm_file.getAtomPtr(atom_index);

atom.size = @intCast(function_body.items.len);

atom.code = function_body.moveToUnmanaged();

atom.relocs = relocations.moveToUnmanaged();

 

try zig_object.synthetic_functions.append(gpa, atom_index);

return sym_index;

}

 

/// Appends a new `std.wasm.Func` to the list of functions and returns its index.

fn appendFunction(zig_object: *ZigObject, gpa: std.mem.Allocator, func: std.wasm.Func) !u32 {

const index: u32 = if (zig_object.functions_free_list.popOrNull()) |idx|

idx

else idx: {

const len: u32 = @intCast(zig_object.functions.items.len);

_ = try zig_object.functions.addOne(gpa);

break :idx len;

};

zig_object.functions.items[index] = func;

 

return index;

}

 

pub fn flushModule(zig_object: *ZigObject, wasm_file: *Wasm) !void {

try zig_object.populateErrorNameTable(wasm_file);

try zig_object.setupErrorsLen(wasm_file);

}

 

const build_options = @import("build_options");

const builtin = @import("builtin");

const codegen = @import("../../codegen.zig");

const link = @import("../../link.zig");

const log = std.log.scoped(.zig_object);

const std = @import("std");

const types = @import("types.zig");

 

const Air = @import("../../Air.zig");

const Atom = @import("Atom.zig");

const Dwarf = @import("../Dwarf.zig");

const File = @import("file.zig").File;

const InternPool = @import("../../InternPool.zig");

const Liveness = @import("../../Liveness.zig");

const Module = @import("../../Module.zig");

const StringTable = @import("../StringTable.zig");

const Symbol = @import("Symbol.zig");

const Type = @import("../../type.zig").Type;

const TypedValue = @import("../../TypedValue.zig");

const Value = @import("../../Value.zig");

const Wasm = @import("../Wasm.zig");

const ZigObject = @This();

pub const File = union(enum) {

zig_object: *ZigObject,

object: *Object,

 

pub const Index = enum(u16) {

null = std.math.maxInt(u16),

_,

};

 

pub fn path(file: File) []const u8 {

return switch (file) {

inline else => |obj| obj.path,

};

}

 

pub fn segmentInfo(file: File) []const types.Segment {

return switch (file) {

.zig_object => |obj| obj.segment_info.items,

.object => |obj| obj.segment_info,

};

}

 

pub fn symbol(file: File, index: Symbol.Index) *Symbol {

return switch (file) {

.zig_object => |obj| &obj.symbols.items[@intFromEnum(index)],

.object => |obj| &obj.symtable[@intFromEnum(index)],

};

}

 

pub fn symbols(file: File) []const Symbol {

return switch (file) {

.zig_object => |obj| obj.symbols.items,

.object => |obj| obj.symtable,

};

}

 

pub fn symbolName(file: File, index: Symbol.Index) []const u8 {

switch (file) {

.zig_object => |obj| {

const sym = obj.symbols.items[@intFromEnum(index)];

return obj.string_table.get(sym.name).?;

},

.object => |obj| {

const sym = obj.symtable[@intFromEnum(index)];

return obj.string_table.get(sym.name);

},

}

}

 

pub fn parseSymbolIntoAtom(file: File, wasm_file: *Wasm, index: Symbol.Index) !AtomIndex {

return switch (file) {

inline else => |obj| obj.parseSymbolIntoAtom(wasm_file, index),

};

}

 

/// For a given symbol index, find its corresponding import.

/// Asserts import exists.

pub fn import(file: File, symbol_index: Symbol.Index) types.Import {

return switch (file) {

.zig_object => |obj| obj.imports.get(symbol_index).?,

.object => |obj| obj.findImport(obj.symtable[@intFromEnum(symbol_index)]),

};

}

 

/// For a given offset, returns its string value.

/// Asserts string exists in the object string table.

pub fn string(file: File, offset: u32) []const u8 {

return switch (file) {

.zig_object => |obj| obj.string_table.get(offset).?,

.object => |obj| obj.string_table.get(offset),

};

}

 

pub fn importedGlobals(file: File) u32 {

return switch (file) {

inline else => |obj| obj.imported_globals_count,

};

}

 

pub fn importedFunctions(file: File) u32 {

return switch (file) {

inline else => |obj| obj.imported_functions_count,

};

}

 

pub fn importedTables(file: File) u32 {

return switch (file) {

inline else => |obj| obj.imported_tables_count,

};

}

 

pub fn function(file: File, sym_index: Symbol.Index) std.wasm.Func {

switch (file) {

.zig_object => |obj| {

const sym = obj.symbols.items[@intFromEnum(sym_index)];

return obj.functions.items[sym.index];

},

.object => |obj| {

const sym = obj.symtable[@intFromEnum(sym_index)];

return obj.functions[sym.index - obj.imported_functions_count];

},

}

}

 

pub fn globals(file: File) []const std.wasm.Global {

return switch (file) {

.zig_object => |obj| obj.globals.items,

.object => |obj| obj.globals,

};

}

 

pub fn funcTypes(file: File) []const std.wasm.Type {

return switch (file) {

.zig_object => |obj| obj.func_types.items,

.object => |obj| obj.func_types,

};

}

 

pub const Entry = union(enum) {

zig_object: ZigObject,

object: Object,

};

};

 

const std = @import("std");

const types = @import("types.zig");

 

const AtomIndex = @import("Atom.zig").Index;

const Object = @import("Object.zig");

const Symbol = @import("Symbol.zig");

const Wasm = @import("../Wasm.zig");

const ZigObject = @import("ZigObject.zig");

.{

.build_root = "test/link/wasm/archive",

.import = @import("link/wasm/archive/build.zig"),

},

.{

.build_root = "test/link/wasm/export-data",

.import = @import("link/wasm/export-data/build.zig"),

},

.{

.build_root = "test/link/wasm/shared-memory",

.import = @import("link/wasm/shared-memory/build.zig"),

},

.target = b.resolveTargetQuery(.{ .cpu_arch = .wasm32, .os_tag = .freestanding }),

lib.root_module.export_symbol_names = &.{"foo"};

.target = b.resolveTargetQuery(.{ .cpu_arch = .wasm32, .os_tag = .freestanding }),

const exe = b.addExecutable(.{

.target = b.resolveTargetQuery(.{

}),

exe.entry = .disabled;

exe.use_lld = false;

exe.import_memory = true;

exe.export_memory = true;

exe.shared_memory = true;

exe.max_memory = 67108864;

exe.root_module.export_symbol_names = &.{"foo"};

const check_exe = exe.checkObject();

check_exe.checkInHeaders();

check_exe.checkExact("Section import");

check_exe.checkExact("entries 1");

check_exe.checkExact("module env");

check_exe.checkExact("name memory"); // ensure we are importing memory

check_exe.checkInHeaders();

check_exe.checkExact("Section export");

check_exe.checkExact("entries 2");

check_exe.checkExact("name memory"); // ensure we also export memory again

check_exe.checkInHeaders();

check_exe.checkExact("Section start");

check_exe.checkInHeaders();

check_exe.checkExact("Section data_count");

check_exe.checkExact("count 1");

check_exe.checkInHeaders();

check_exe.checkExact("Section custom");

check_exe.checkExact("name name");

check_exe.checkExact("type function");

check_exe.checkExact("name __wasm_init_memory");

check_exe.checkExact("name __wasm_init_tls");

check_exe.checkExact("type global");

check_exe.checkExact("name __tls_base");

check_exe.checkExact("name __tls_size");

check_exe.checkExact("name __tls_align");

 

check_exe.checkExact("type data_segment");

check_exe.checkExact("names 1");

check_exe.checkExact("index 0");

check_exe.checkExact("name .tdata");

test_step.dependOn(&check_exe.step);

const exe = b.addExecutable(.{

exe.entry = .disabled;

exe.use_llvm = false;

exe.use_lld = false;

exe.root_module.export_symbol_names = &.{"foo"};

b.installArtifact(exe);

const check_exe = exe.checkObject();

check_exe.checkInHeaders();

check_exe.checkExact("Section type");

check_exe.checkExact("entries 2");

check_exe.checkExact("params 1");

check_exe.checkExact("type i32");

check_exe.checkExact("returns 1");

check_exe.checkExact("type i64");

check_exe.checkExact("params 0");

check_exe.checkExact("returns 0");

test_step.dependOn(&check_exe.step);