| ... | ... | @@ -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,78 @@ 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 | | /// 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) = .{}, |
| 53 | 42 | /// List of all `Decl` that are currently alive. |
| 54 | 43 | /// This is ment for bookkeeping so we can safely cleanup all codegen memory |
| 55 | 44 | /// when calling `deinit` |
| 56 | | symbols: std.ArrayListUnmanaged(*Module.Decl) = .{}, |
| 45 | decls: std.AutoHashMapUnmanaged(*Module.Decl, void) = .{}, |
| 46 | /// List of all symbols. |
| 47 | symbols: std.ArrayListUnmanaged(Symbol) = .{}, |
| 57 | 48 | /// List of symbol indexes which are free to be used. |
| 58 | 49 | symbols_free_list: std.ArrayListUnmanaged(u32) = .{}, |
| 50 | /// Maps atoms to their segment index |
| 51 | atoms: std.AutoHashMapUnmanaged(u32, *Atom) = .{}, |
| 52 | /// Represents the index into `segments` where the 'code' section |
| 53 | /// lives. |
| 54 | code_section_index: ?u32 = null, |
| 55 | /// The count of imported functions. This number will be appended |
| 56 | /// to the function indexes as their index starts at the lowest non-extern function. |
| 57 | imported_functions_count: u32 = 0, |
| 58 | /// Map of symbol indexes, represented by its `wasm.Import` |
| 59 | imports: std.AutoHashMapUnmanaged(u32, wasm.Import) = .{}, |
| 60 | /// Represents non-synthetic section entries. |
| 61 | /// Used for code, data and custom sections. |
| 62 | segments: std.ArrayListUnmanaged(Segment) = .{}, |
| 63 | /// Maps a data segment key (such as .rodata) to the index into `segments`. |
| 64 | data_segments: std.StringArrayHashMapUnmanaged(u32) = .{}, |
| 65 | /// A list of `types.Segment` which provide meta data |
| 66 | /// about a data symbol such as its name |
| 67 | segment_info: std.ArrayListUnmanaged(types.Segment) = .{}, |
| 68 | |
| 69 | // Output sections |
| 70 | /// Output type section |
| 71 | func_types: std.ArrayListUnmanaged(wasm.Type) = .{}, |
| 72 | /// Output function section |
| 73 | functions: std.ArrayListUnmanaged(wasm.Func) = .{}, |
| 74 | /// Output global section |
| 75 | globals: std.ArrayListUnmanaged(wasm.Global) = .{}, |
| 76 | /// Memory section |
| 77 | memories: wasm.Memory = .{ .limits = .{ .min = 0, .max = null } }, |
| 78 | |
| 79 | /// Indirect function table, used to call function pointers |
| 80 | /// When this is non-zero, we must emit a table entry, |
| 81 | /// as well as an 'elements' section. |
| 82 | function_table: std.ArrayListUnmanaged(Symbol) = .{}, |
| 83 | |
| 84 | pub const Segment = struct { |
| 85 | alignment: u32, |
| 86 | size: u32, |
| 87 | offset: u32, |
| 88 | }; |
| 59 | 89 | |
| 60 | 90 | 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 }), |
| 91 | type_index: u32, |
| 69 | 92 | |
| 70 | 93 | pub const empty: FnData = .{ |
| 71 | | .functype = .{}, |
| 72 | | .code = .{}, |
| 73 | | .idx_refs = .{}, |
| 94 | .type_index = undefined, |
| 74 | 95 | }; |
| 75 | 96 | }; |
| 76 | 97 | |
| 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 | 98 | pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Options) !*Wasm { |
| 121 | 99 | assert(options.object_format == .wasm); |
| 122 | 100 | |
| ... | ... | @@ -139,6 +117,22 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio |
| 139 | 117 | |
| 140 | 118 | try file.writeAll(&(wasm.magic ++ wasm.version)); |
| 141 | 119 | |
| 120 | // As sym_index '0' is reserved, we use it for our stack pointer symbol |
| 121 | const global = try wasm_bin.globals.addOne(allocator); |
| 122 | global.* = .{ |
| 123 | .global_type = .{ |
| 124 | .valtype = .i32, |
| 125 | .mutable = true, |
| 126 | }, |
| 127 | .init = .{ .i32_const = 0 }, |
| 128 | }; |
| 129 | const symbol = try wasm_bin.symbols.addOne(allocator); |
| 130 | symbol.* = .{ |
| 131 | .name = "__stack_pointer", |
| 132 | .tag = .global, |
| 133 | .flags = 0, |
| 134 | .index = 0, |
| 135 | }; |
| 142 | 136 | return wasm_bin; |
| 143 | 137 | } |
| 144 | 138 | |
| ... | ... | @@ -160,63 +154,57 @@ pub fn deinit(self: *Wasm) void { |
| 160 | 154 | if (self.llvm_object) |llvm_object| llvm_object.destroy(self.base.allocator); |
| 161 | 155 | } |
| 162 | 156 | |
| 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); |
| 157 | var decl_it = self.decls.keyIterator(); |
| 158 | while (decl_it.next()) |decl_ptr| { |
| 159 | const decl = decl_ptr.*; |
| 160 | decl.link.wasm.deinit(self.base.allocator); |
| 177 | 161 | } |
| 178 | 162 | |
| 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); |
| 163 | for (self.func_types.items) |func_type| { |
| 164 | self.base.allocator.free(func_type.params); |
| 165 | self.base.allocator.free(func_type.returns); |
| 166 | } |
| 167 | for (self.segment_info.items) |segment_info| { |
| 168 | self.base.allocator.free(segment_info.name); |
| 169 | } |
| 170 | |
| 171 | self.decls.deinit(self.base.allocator); |
| 183 | 172 | self.symbols.deinit(self.base.allocator); |
| 184 | 173 | self.symbols_free_list.deinit(self.base.allocator); |
| 174 | self.atoms.deinit(self.base.allocator); |
| 175 | self.segments.deinit(self.base.allocator); |
| 176 | self.data_segments.deinit(self.base.allocator); |
| 177 | self.segment_info.deinit(self.base.allocator); |
| 178 | |
| 179 | // free output sections |
| 180 | self.imports.deinit(self.base.allocator); |
| 181 | self.func_types.deinit(self.base.allocator); |
| 182 | self.functions.deinit(self.base.allocator); |
| 183 | self.globals.deinit(self.base.allocator); |
| 184 | self.function_table.deinit(self.base.allocator); |
| 185 | 185 | } |
| 186 | 186 | |
| 187 | 187 | pub fn allocateDeclIndexes(self: *Wasm, decl: *Module.Decl) !void { |
| 188 | | if (decl.link.wasm.init) return; |
| 188 | if (decl.link.wasm.sym_index != 0) return; |
| 189 | 189 | |
| 190 | | try self.offset_table.ensureUnusedCapacity(self.base.allocator, 1); |
| 191 | 190 | try self.symbols.ensureUnusedCapacity(self.base.allocator, 1); |
| 191 | try self.decls.putNoClobber(self.base.allocator, decl, {}); |
| 192 | 192 | |
| 193 | | const block = &decl.link.wasm; |
| 194 | | block.init = true; |
| 193 | const atom = &decl.link.wasm; |
| 195 | 194 | |
| 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 | | } |
| 195 | var symbol: Symbol = .{ |
| 196 | .name = undefined, // will be set after updateDecl |
| 197 | .flags = 0, |
| 198 | .tag = undefined, // will be set after updateDecl |
| 199 | .index = undefined, // will be set after updateDecl |
| 200 | }; |
| 202 | 201 | |
| 203 | 202 | if (self.symbols_free_list.popOrNull()) |index| { |
| 204 | | block.symbol_index = index; |
| 205 | | self.symbols.items[block.symbol_index] = decl; |
| 203 | atom.sym_index = index; |
| 204 | self.symbols.items[index] = symbol; |
| 206 | 205 | } 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 | | } |
| 206 | atom.sym_index = @intCast(u32, self.symbols.items.len); |
| 207 | self.symbols.appendAssumeCapacity(symbol); |
| 220 | 208 | } |
| 221 | 209 | } |
| 222 | 210 | |
| ... | ... | @@ -228,25 +216,21 @@ pub fn updateFunc(self: *Wasm, module: *Module, func: *Module.Fn, air: Air, live |
| 228 | 216 | if (self.llvm_object) |llvm_object| return llvm_object.updateFunc(module, func, air, liveness); |
| 229 | 217 | } |
| 230 | 218 | const decl = func.owner_decl; |
| 231 | | assert(decl.link.wasm.init); // Must call allocateDeclIndexes() |
| 219 | assert(decl.link.wasm.sym_index != 0); // Must call allocateDeclIndexes() |
| 232 | 220 | |
| 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; |
| 221 | decl.link.wasm.clear(); |
| 237 | 222 | |
| 238 | 223 | var codegen: CodeGen = .{ |
| 239 | 224 | .gpa = self.base.allocator, |
| 240 | 225 | .air = air, |
| 241 | 226 | .liveness = liveness, |
| 242 | 227 | .values = .{}, |
| 243 | | .code = fn_data.code.toManaged(self.base.allocator), |
| 244 | | .func_type_data = fn_data.functype.toManaged(self.base.allocator), |
| 228 | .code = std.ArrayList(u8).init(self.base.allocator), |
| 245 | 229 | .decl = decl, |
| 246 | 230 | .err_msg = undefined, |
| 247 | 231 | .locals = .{}, |
| 248 | 232 | .target = self.base.options.target, |
| 249 | | .bin_file = &self.base, |
| 233 | .bin_file = self, |
| 250 | 234 | .global_error_set = self.base.options.module.?.global_error_set, |
| 251 | 235 | }; |
| 252 | 236 | defer codegen.deinit(); |
| ... | ... | @@ -272,26 +256,21 @@ pub fn updateDecl(self: *Wasm, module: *Module, decl: *Module.Decl) !void { |
| 272 | 256 | if (build_options.have_llvm) { |
| 273 | 257 | if (self.llvm_object) |llvm_object| return llvm_object.updateDecl(module, decl); |
| 274 | 258 | } |
| 275 | | assert(decl.link.wasm.init); // Must call allocateDeclIndexes() |
| 259 | assert(decl.link.wasm.sym_index != 0); // Must call allocateDeclIndexes() |
| 276 | 260 | |
| 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; |
| 261 | decl.link.wasm.clear(); |
| 282 | 262 | |
| 283 | 263 | var codegen: CodeGen = .{ |
| 284 | 264 | .gpa = self.base.allocator, |
| 285 | 265 | .air = undefined, |
| 286 | 266 | .liveness = undefined, |
| 287 | 267 | .values = .{}, |
| 288 | | .code = fn_data.code.toManaged(self.base.allocator), |
| 289 | | .func_type_data = fn_data.functype.toManaged(self.base.allocator), |
| 268 | .code = std.ArrayList(u8).init(self.base.allocator), |
| 290 | 269 | .decl = decl, |
| 291 | 270 | .err_msg = undefined, |
| 292 | 271 | .locals = .{}, |
| 293 | 272 | .target = self.base.options.target, |
| 294 | | .bin_file = &self.base, |
| 273 | .bin_file = self, |
| 295 | 274 | .global_error_set = self.base.options.module.?.global_error_set, |
| 296 | 275 | }; |
| 297 | 276 | defer codegen.deinit(); |
| ... | ... | @@ -310,33 +289,19 @@ pub fn updateDecl(self: *Wasm, module: *Module, decl: *Module.Decl) !void { |
| 310 | 289 | } |
| 311 | 290 | |
| 312 | 291 | 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 | 292 | const code: []const u8 = switch (result) { |
| 319 | | .appended => @as([]const u8, fn_data.code.items), |
| 293 | .appended => @as([]const u8, codegen.code.items), |
| 320 | 294 | .externally_managed => |payload| payload, |
| 321 | 295 | }; |
| 322 | 296 | |
| 323 | | const block = &decl.link.wasm; |
| 324 | | if (decl.ty.zigTypeTag() != .Fn) { |
| 325 | | block.size = @intCast(u32, code.len); |
| 326 | | block.data = code.ptr; |
| 297 | if (decl.isExtern()) { |
| 298 | try self.addOrUpdateImport(decl); |
| 327 | 299 | } |
| 328 | 300 | |
| 329 | | // If we're updating an existing decl, unplug it first |
| 330 | | // to avoid infinite loops due to earlier links |
| 331 | | block.unplug(); |
| 332 | | |
| 333 | | if (self.last_block) |last| { |
| 334 | | if (last != block) { |
| 335 | | last.next = block; |
| 336 | | block.prev = last; |
| 337 | | } |
| 338 | | } |
| 339 | | self.last_block = block; |
| 301 | if (code.len == 0) return; |
| 302 | const atom: *Atom = &decl.link.wasm; |
| 303 | atom.size = @intCast(u32, code.len); |
| 304 | try atom.code.appendSlice(self.base.allocator, code); |
| 340 | 305 | } |
| 341 | 306 | |
| 342 | 307 | pub fn updateDeclExports( |
| ... | ... | @@ -357,30 +322,240 @@ pub fn freeDecl(self: *Wasm, decl: *Module.Decl) void { |
| 357 | 322 | if (build_options.have_llvm) { |
| 358 | 323 | if (self.llvm_object) |llvm_object| return llvm_object.freeDecl(decl); |
| 359 | 324 | } |
| 325 | const atom = &decl.link.wasm; |
| 326 | self.symbols_free_list.append(self.base.allocator, atom.sym_index) catch {}; |
| 327 | atom.deinit(self.base.allocator); |
| 328 | _ = self.decls.remove(decl); |
| 329 | |
| 330 | if (decl.isExtern()) { |
| 331 | const import = self.imports.fetchRemove(decl.link.wasm.sym_index).?.value; |
| 332 | switch (import.kind) { |
| 333 | .function => self.imported_functions_count -= 1, |
| 334 | else => unreachable, |
| 335 | } |
| 336 | } |
| 337 | } |
| 338 | |
| 339 | fn addOrUpdateImport(self: *Wasm, decl: *Module.Decl) !void { |
| 340 | const symbol_index = decl.link.wasm.sym_index; |
| 341 | const symbol: *Symbol = &self.symbols.items[symbol_index]; |
| 342 | symbol.name = decl.name; |
| 343 | symbol.setUndefined(true); |
| 344 | switch (decl.ty.zigTypeTag()) { |
| 345 | .Fn => { |
| 346 | const gop = try self.imports.getOrPut(self.base.allocator, symbol_index); |
| 347 | if (!gop.found_existing) { |
| 348 | self.imported_functions_count += 1; |
| 349 | gop.value_ptr.* = .{ |
| 350 | .module_name = self.host_name, |
| 351 | .name = std.mem.span(symbol.name), |
| 352 | .kind = .{ .function = decl.fn_link.wasm.type_index }, |
| 353 | }; |
| 354 | } |
| 355 | }, |
| 356 | else => @panic("TODO: Implement undefined symbols for non-function declarations"), |
| 357 | } |
| 358 | } |
| 359 | |
| 360 | fn parseDeclIntoAtom(self: *Wasm, decl: *Module.Decl) !void { |
| 361 | const atom: *Atom = &decl.link.wasm; |
| 362 | const symbol: *Symbol = &self.symbols.items[atom.sym_index]; |
| 363 | symbol.name = decl.name; |
| 364 | atom.alignment = decl.ty.abiAlignment(self.base.options.target); |
| 365 | const final_index: u32 = switch (decl.ty.zigTypeTag()) { |
| 366 | .Fn => result: { |
| 367 | const fn_data = decl.fn_link.wasm; |
| 368 | const type_index = fn_data.type_index; |
| 369 | const index = @intCast(u32, self.functions.items.len + self.imported_functions_count); |
| 370 | try self.functions.append(self.base.allocator, .{ .type_index = type_index }); |
| 371 | symbol.tag = .function; |
| 372 | symbol.index = index; |
| 373 | |
| 374 | if (self.code_section_index == null) { |
| 375 | self.code_section_index = @intCast(u32, self.segments.items.len); |
| 376 | try self.segments.append(self.base.allocator, .{ |
| 377 | .alignment = atom.alignment, |
| 378 | .size = atom.size, |
| 379 | .offset = 0, |
| 380 | }); |
| 381 | } |
| 382 | |
| 383 | break :result self.code_section_index.?; |
| 384 | }, |
| 385 | else => result: { |
| 386 | const gop = try self.data_segments.getOrPut(self.base.allocator, ".rodata"); |
| 387 | const atom_index = if (gop.found_existing) blk: { |
| 388 | self.segments.items[gop.value_ptr.*].size += atom.size; |
| 389 | break :blk gop.value_ptr.*; |
| 390 | } else blk: { |
| 391 | const index = @intCast(u32, self.segments.items.len); |
| 392 | try self.segments.append(self.base.allocator, .{ |
| 393 | .alignment = atom.alignment, |
| 394 | .size = 0, |
| 395 | .offset = 0, |
| 396 | }); |
| 397 | gop.value_ptr.* = index; |
| 398 | break :blk index; |
| 399 | }; |
| 400 | const info_index = @intCast(u32, self.segment_info.items.len); |
| 401 | const segment_name = try std.mem.concat(self.base.allocator, u8, &.{ |
| 402 | ".rodata.", |
| 403 | std.mem.span(symbol.name), |
| 404 | }); |
| 405 | errdefer self.base.allocator.free(segment_name); |
| 406 | try self.segment_info.append(self.base.allocator, .{ |
| 407 | .name = segment_name, |
| 408 | .alignment = atom.alignment, |
| 409 | .flags = 0, |
| 410 | }); |
| 411 | symbol.tag = .data; |
| 412 | symbol.index = info_index; |
| 413 | atom.alignment = decl.ty.abiAlignment(self.base.options.target); |
| 414 | |
| 415 | break :result atom_index; |
| 416 | }, |
| 417 | }; |
| 418 | |
| 419 | const segment: *Segment = &self.segments.items[final_index]; |
| 420 | segment.alignment = std.math.max(segment.alignment, atom.alignment); |
| 421 | segment.size = std.mem.alignForwardGeneric( |
| 422 | u32, |
| 423 | std.mem.alignForwardGeneric(u32, segment.size, atom.alignment) + atom.size, |
| 424 | segment.alignment, |
| 425 | ); |
| 426 | |
| 427 | if (self.atoms.getPtr(final_index)) |last| { |
| 428 | last.*.next = atom; |
| 429 | atom.prev = last.*; |
| 430 | last.* = atom; |
| 431 | } else { |
| 432 | try self.atoms.putNoClobber(self.base.allocator, final_index, atom); |
| 433 | } |
| 434 | } |
| 360 | 435 | |
| 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), |
| 436 | fn allocateAtoms(self: *Wasm) !void { |
| 437 | var it = self.atoms.iterator(); |
| 438 | while (it.next()) |entry| { |
| 439 | var atom: *Atom = entry.value_ptr.*.getFirst(); |
| 440 | var offset: u32 = 0; |
| 441 | while (true) { |
| 442 | offset = std.mem.alignForwardGeneric(u32, offset, atom.alignment); |
| 443 | atom.offset = offset; |
| 444 | log.debug("Atom '{s}' allocated from 0x{x:0>8} to 0x{x:0>8} size={d}", .{ |
| 445 | self.symbols.items[atom.sym_index].name, |
| 446 | offset, |
| 447 | offset + atom.size, |
| 448 | atom.size, |
| 449 | }); |
| 450 | offset += atom.size; |
| 451 | atom = atom.next orelse break; |
| 452 | } |
| 453 | } |
| 454 | } |
| 455 | |
| 456 | fn setupImports(self: *Wasm) void { |
| 457 | var function_index: u32 = 0; |
| 458 | var it = self.imports.iterator(); |
| 459 | while (it.next()) |entry| { |
| 460 | const symbol = &self.symbols.items[entry.key_ptr.*]; |
| 461 | const import: wasm.Import = entry.value_ptr.*; |
| 462 | switch (import.kind) { |
| 463 | .function => { |
| 464 | symbol.index = function_index; |
| 465 | function_index += 1; |
| 466 | }, |
| 365 | 467 | else => unreachable, |
| 366 | 468 | } |
| 367 | 469 | } |
| 368 | | const block = &decl.link.wasm; |
| 470 | } |
| 369 | 471 | |
| 370 | | if (self.last_block == block) { |
| 371 | | self.last_block = block.prev; |
| 472 | /// Sets up the memory section of the wasm module, as well as the stack. |
| 473 | fn setupMemory(self: *Wasm) !void { |
| 474 | log.debug("Setting up memory layout", .{}); |
| 475 | const page_size = 64 * 1024; |
| 476 | const stack_size = self.base.options.stack_size_override orelse page_size * 1; |
| 477 | const stack_alignment = 16; |
| 478 | var memory_ptr: u64 = self.base.options.global_base orelse 1024; |
| 479 | memory_ptr = std.mem.alignForwardGeneric(u64, memory_ptr, stack_alignment); |
| 480 | |
| 481 | var offset: u32 = @intCast(u32, memory_ptr); |
| 482 | for (self.segments.items) |*segment, i| { |
| 483 | // skip 'code' segments |
| 484 | if (self.code_section_index) |index| { |
| 485 | if (index == i) continue; |
| 486 | } |
| 487 | memory_ptr = std.mem.alignForwardGeneric(u64, memory_ptr, segment.alignment); |
| 488 | memory_ptr += segment.size; |
| 489 | segment.offset = offset; |
| 490 | offset += segment.size; |
| 372 | 491 | } |
| 373 | 492 | |
| 374 | | block.unplug(); |
| 493 | memory_ptr = std.mem.alignForwardGeneric(u64, memory_ptr, stack_alignment); |
| 494 | memory_ptr += stack_size; |
| 495 | |
| 496 | // Setup the max amount of pages |
| 497 | // For now we only support wasm32 by setting the maximum allowed memory size 2^32-1 |
| 498 | const max_memory_allowed: u64 = (1 << 32) - 1; |
| 375 | 499 | |
| 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 {}; |
| 500 | if (self.base.options.initial_memory) |initial_memory| { |
| 501 | if (!std.mem.isAlignedGeneric(u64, initial_memory, page_size)) { |
| 502 | log.err("Initial memory must be {d}-byte aligned", .{page_size}); |
| 503 | return error.MissAlignment; |
| 504 | } |
| 505 | if (memory_ptr > initial_memory) { |
| 506 | log.err("Initial memory too small, must be at least {d} bytes", .{memory_ptr}); |
| 507 | return error.MemoryTooSmall; |
| 508 | } |
| 509 | if (initial_memory > max_memory_allowed) { |
| 510 | log.err("Initial memory exceeds maximum memory {d}", .{max_memory_allowed}); |
| 511 | return error.MemoryTooBig; |
| 512 | } |
| 513 | memory_ptr = initial_memory; |
| 514 | } |
| 378 | 515 | |
| 379 | | block.init = false; |
| 516 | // In case we do not import memory, but define it ourselves, |
| 517 | // set the minimum amount of pages on the memory section. |
| 518 | self.memories.limits.min = @intCast(u32, std.mem.alignForwardGeneric(u64, memory_ptr, page_size) / page_size); |
| 519 | log.debug("Total memory pages: {d}", .{self.memories.limits.min}); |
| 380 | 520 | |
| 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); |
| 521 | if (self.base.options.max_memory) |max_memory| { |
| 522 | if (!std.mem.isAlignedGeneric(u64, max_memory, page_size)) { |
| 523 | log.err("Maximum memory must be {d}-byte aligned", .{page_size}); |
| 524 | return error.MissAlignment; |
| 525 | } |
| 526 | if (memory_ptr > max_memory) { |
| 527 | log.err("Maxmimum memory too small, must be at least {d} bytes", .{memory_ptr}); |
| 528 | return error.MemoryTooSmall; |
| 529 | } |
| 530 | if (max_memory > max_memory_allowed) { |
| 531 | log.err("Maximum memory exceeds maxmium amount {d}", .{max_memory_allowed}); |
| 532 | return error.MemoryTooBig; |
| 533 | } |
| 534 | self.memories.limits.max = @intCast(u32, max_memory / page_size); |
| 535 | log.debug("Maximum memory pages: {d}", .{self.memories.limits.max}); |
| 536 | } |
| 537 | |
| 538 | // We always put the stack pointer global at index 0 |
| 539 | self.globals.items[0].init.i32_const = @bitCast(i32, @intCast(u32, memory_ptr)); |
| 540 | } |
| 541 | |
| 542 | fn resetState(self: *Wasm) void { |
| 543 | for (self.segment_info.items) |*segment_info| { |
| 544 | self.base.allocator.free(segment_info.name); |
| 545 | } |
| 546 | var decl_it = self.decls.keyIterator(); |
| 547 | while (decl_it.next()) |decl| { |
| 548 | const atom = &decl.*.link.wasm; |
| 549 | atom.next = null; |
| 550 | atom.prev = null; |
| 551 | } |
| 552 | self.functions.clearRetainingCapacity(); |
| 553 | self.segments.clearRetainingCapacity(); |
| 554 | self.segment_info.clearRetainingCapacity(); |
| 555 | self.data_segments.clearRetainingCapacity(); |
| 556 | self.function_table.clearRetainingCapacity(); |
| 557 | self.atoms.clearRetainingCapacity(); |
| 558 | self.code_section_index = null; |
| 384 | 559 | } |
| 385 | 560 | |
| 386 | 561 | pub fn flush(self: *Wasm, comp: *Compilation) !void { |
| ... | ... | @@ -396,29 +571,21 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 396 | 571 | const tracy = trace(@src()); |
| 397 | 572 | defer tracy.end(); |
| 398 | 573 | |
| 574 | // When we finish/error we reset the state of the linker |
| 575 | // So we can rebuild the binary file on each incremental update |
| 576 | defer self.resetState(); |
| 577 | self.setupImports(); |
| 578 | var decl_it = self.decls.keyIterator(); |
| 579 | while (decl_it.next()) |decl| { |
| 580 | if (decl.*.isExtern()) continue; |
| 581 | try self.parseDeclIntoAtom(decl.*); |
| 582 | } |
| 583 | |
| 584 | try self.setupMemory(); |
| 585 | try self.allocateAtoms(); |
| 586 | |
| 399 | 587 | const file = self.base.file.?; |
| 400 | 588 | 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 | | // The size of the emulated stack |
| 408 | | const stack_size = @intCast(u32, self.base.options.stack_size_override orelse std.wasm.page_size); |
| 409 | | |
| 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; |
| 418 | | } |
| 419 | | first_decl = cur; |
| 420 | | break :blk size; |
| 421 | | } else 0; |
| 422 | 589 | |
| 423 | 590 | // No need to rewrite the magic/version header |
| 424 | 591 | try file.setEndPos(@sizeOf(@TypeOf(wasm.magic ++ wasm.version))); |
| ... | ... | @@ -427,38 +594,46 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 427 | 594 | // Type section |
| 428 | 595 | { |
| 429 | 596 | const header_offset = try reserveVecSectionHeader(file); |
| 597 | const writer = file.writer(); |
| 430 | 598 | |
| 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); |
| 599 | for (self.func_types.items) |func_type| { |
| 600 | try leb.writeULEB128(writer, wasm.function_type); |
| 601 | try leb.writeULEB128(writer, @intCast(u32, func_type.params.len)); |
| 602 | for (func_type.params) |param_ty| try leb.writeULEB128(writer, wasm.valtype(param_ty)); |
| 603 | try leb.writeULEB128(writer, @intCast(u32, func_type.returns.len)); |
| 604 | for (func_type.returns) |ret_ty| try leb.writeULEB128(writer, wasm.valtype(ret_ty)); |
| 605 | } |
| 435 | 606 | |
| 436 | 607 | try writeVecSectionHeader( |
| 437 | 608 | file, |
| 438 | 609 | header_offset, |
| 439 | 610 | .type, |
| 440 | 611 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 441 | | @intCast(u32, self.ext_funcs.items.len + self.funcs.items.len), |
| 612 | @intCast(u32, self.func_types.items.len), |
| 442 | 613 | ); |
| 443 | 614 | } |
| 444 | 615 | |
| 445 | 616 | // Import section |
| 446 | | { |
| 447 | | // TODO: implement non-functions imports |
| 617 | const import_mem = self.base.options.import_memory; |
| 618 | if (self.imports.count() != 0 or import_mem) { |
| 448 | 619 | const header_offset = try reserveVecSectionHeader(file); |
| 449 | 620 | const writer = file.writer(); |
| 450 | | for (self.ext_funcs.items) |decl, typeidx| { |
| 451 | | try leb.writeULEB128(writer, @intCast(u32, self.host_name.len)); |
| 452 | | try writer.writeAll(self.host_name); |
| 453 | 621 | |
| 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]); |
| 622 | var it = self.imports.iterator(); |
| 623 | while (it.next()) |entry| { |
| 624 | const import_symbol = self.symbols.items[entry.key_ptr.*]; |
| 625 | std.debug.assert(import_symbol.isUndefined()); |
| 626 | const import = entry.value_ptr.*; |
| 627 | try emitImport(writer, import); |
| 628 | } |
| 458 | 629 | |
| 459 | | // emit kind and the function type |
| 460 | | try writer.writeByte(wasm.externalKind(.function)); |
| 461 | | try leb.writeULEB128(writer, @intCast(u32, typeidx)); |
| 630 | if (import_mem) { |
| 631 | const mem_imp: wasm.Import = .{ |
| 632 | .module_name = self.host_name, |
| 633 | .name = "memory", |
| 634 | .kind = .{ .memory = self.memories.limits }, |
| 635 | }; |
| 636 | try emitImport(writer, mem_imp); |
| 462 | 637 | } |
| 463 | 638 | |
| 464 | 639 | try writeVecSectionHeader( |
| ... | ... | @@ -466,7 +641,7 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 466 | 641 | header_offset, |
| 467 | 642 | .import, |
| 468 | 643 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 469 | | @intCast(u32, self.ext_funcs.items.len), |
| 644 | @intCast(u32, self.imports.count() + @boolToInt(import_mem)), |
| 470 | 645 | ); |
| 471 | 646 | } |
| 472 | 647 | |
| ... | ... | @@ -474,9 +649,8 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 474 | 649 | { |
| 475 | 650 | const header_offset = try reserveVecSectionHeader(file); |
| 476 | 651 | 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); |
| 652 | for (self.functions.items) |function| { |
| 653 | try leb.writeULEB128(writer, function.type_index); |
| 480 | 654 | } |
| 481 | 655 | |
| 482 | 656 | try writeVecSectionHeader( |
| ... | ... | @@ -484,26 +658,16 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 484 | 658 | header_offset, |
| 485 | 659 | .function, |
| 486 | 660 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 487 | | @intCast(u32, self.funcs.items.len), |
| 661 | @intCast(u32, self.functions.items.len), |
| 488 | 662 | ); |
| 489 | 663 | } |
| 490 | 664 | |
| 491 | 665 | // Memory section |
| 492 | | { |
| 666 | if (!self.base.options.import_memory) { |
| 493 | 667 | const header_offset = try reserveVecSectionHeader(file); |
| 494 | 668 | const writer = file.writer(); |
| 495 | 669 | |
| 496 | | try leb.writeULEB128(writer, @as(u32, 0)); |
| 497 | | // Calculate the amount of memory pages are required and write them. |
| 498 | | // Wasm uses 64kB page sizes. Round up to ensure the data segments fit into the memory |
| 499 | | try leb.writeULEB128( |
| 500 | | writer, |
| 501 | | try std.math.divCeil( |
| 502 | | u32, |
| 503 | | offset_table_size + data_size + stack_size, |
| 504 | | std.wasm.page_size, |
| 505 | | ), |
| 506 | | ); |
| 670 | try emitLimits(writer, self.memories.limits); |
| 507 | 671 | try writeVecSectionHeader( |
| 508 | 672 | file, |
| 509 | 673 | header_offset, |
| ... | ... | @@ -515,29 +679,21 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 515 | 679 | |
| 516 | 680 | // Global section (used to emit stack pointer) |
| 517 | 681 | { |
| 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 | 682 | const header_offset = try reserveVecSectionHeader(file); |
| 525 | 683 | const writer = file.writer(); |
| 526 | 684 | |
| 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)); |
| 685 | for (self.globals.items) |global| { |
| 686 | try writer.writeByte(wasm.valtype(global.global_type.valtype)); |
| 687 | try writer.writeByte(@boolToInt(global.global_type.mutable)); |
| 688 | try emitInit(writer, global.init); |
| 689 | } |
| 534 | 690 | |
| 535 | 691 | try writeVecSectionHeader( |
| 536 | 692 | file, |
| 537 | 693 | header_offset, |
| 538 | 694 | .global, |
| 539 | 695 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 540 | | @as(u32, 1), |
| 696 | @intCast(u32, self.globals.items.len), |
| 541 | 697 | ); |
| 542 | 698 | } |
| 543 | 699 | |
| ... | ... | @@ -554,10 +710,13 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 554 | 710 | |
| 555 | 711 | switch (exprt.exported_decl.ty.zigTypeTag()) { |
| 556 | 712 | .Fn => { |
| 713 | const target = exprt.exported_decl.link.wasm.sym_index; |
| 714 | const target_symbol = self.symbols.items[target]; |
| 715 | std.debug.assert(target_symbol.tag == .function); |
| 557 | 716 | // Type of the export |
| 558 | 717 | try writer.writeByte(wasm.externalKind(.function)); |
| 559 | 718 | // Exported function index |
| 560 | | try leb.writeULEB128(writer, self.getFuncidx(exprt.exported_decl).?); |
| 719 | try leb.writeULEB128(writer, target_symbol.index); |
| 561 | 720 | }, |
| 562 | 721 | else => return error.TODOImplementNonFnDeclsForWasm, |
| 563 | 722 | } |
| ... | ... | @@ -567,7 +726,7 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 567 | 726 | } |
| 568 | 727 | |
| 569 | 728 | // export memory if size is not 0 |
| 570 | | if (data_size != 0) { |
| 729 | if (!self.base.options.import_memory) { |
| 571 | 730 | try leb.writeULEB128(writer, @intCast(u32, "memory".len)); |
| 572 | 731 | try writer.writeAll("memory"); |
| 573 | 732 | try writer.writeByte(wasm.externalKind(.memory)); |
| ... | ... | @@ -585,75 +744,143 @@ pub fn flushModule(self: *Wasm, comp: *Compilation) !void { |
| 585 | 744 | } |
| 586 | 745 | |
| 587 | 746 | // Code section |
| 588 | | { |
| 747 | if (self.code_section_index) |code_index| { |
| 589 | 748 | const header_offset = try reserveVecSectionHeader(file); |
| 590 | 749 | 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); |
| 750 | var atom: *Atom = self.atoms.get(code_index).?.getFirst(); |
| 751 | while (true) { |
| 752 | try atom.resolveRelocs(self); |
| 753 | try leb.writeULEB128(writer, atom.size); |
| 754 | try writer.writeAll(atom.code.items); |
| 755 | atom = atom.next orelse break; |
| 602 | 756 | } |
| 603 | 757 | try writeVecSectionHeader( |
| 604 | 758 | file, |
| 605 | 759 | header_offset, |
| 606 | 760 | .code, |
| 607 | 761 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 608 | | @intCast(u32, self.funcs.items.len), |
| 762 | @intCast(u32, self.functions.items.len), |
| 609 | 763 | ); |
| 610 | 764 | } |
| 611 | 765 | |
| 612 | 766 | // Data section |
| 613 | | if (data_size != 0) { |
| 767 | if (self.data_segments.count() != 0) { |
| 614 | 768 | const header_offset = try reserveVecSectionHeader(file); |
| 615 | 769 | 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 | | |
| 626 | | // offset table + data size |
| 627 | | try leb.writeULEB128(writer, total_size); |
| 628 | 770 | |
| 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; |
| 771 | var it = self.data_segments.iterator(); |
| 772 | var segment_count: u32 = 0; |
| 773 | while (it.next()) |entry| { |
| 774 | // do not output 'bss' section |
| 775 | if (std.mem.eql(u8, entry.key_ptr.*, ".bss")) continue; |
| 776 | segment_count += 1; |
| 777 | const atom_index = entry.value_ptr.*; |
| 778 | var atom: *Atom = self.atoms.getPtr(atom_index).?.*.getFirst(); |
| 779 | var segment = self.segments.items[atom_index]; |
| 780 | |
| 781 | // flag and index to memory section (currently, there can only be 1 memory section in wasm) |
| 782 | try leb.writeULEB128(writer, @as(u32, 0)); |
| 783 | // offset into data section |
| 784 | try emitInit(writer, .{ .i32_const = @bitCast(i32, segment.offset) }); |
| 785 | try leb.writeULEB128(writer, segment.size); |
| 786 | |
| 787 | // fill in the offset table and the data segments |
| 788 | var current_offset: u32 = 0; |
| 789 | while (true) { |
| 790 | try atom.resolveRelocs(self); |
| 791 | |
| 792 | // Pad with zeroes to ensure all segments are aligned |
| 793 | if (current_offset != atom.offset) { |
| 794 | const diff = atom.offset - current_offset; |
| 795 | try writer.writeByteNTimes(0, diff); |
| 796 | current_offset += diff; |
| 797 | } |
| 798 | std.debug.assert(current_offset == atom.offset); |
| 799 | std.debug.assert(atom.code.items.len == atom.size); |
| 800 | try writer.writeAll(atom.code.items); |
| 801 | |
| 802 | current_offset += atom.size; |
| 803 | if (atom.next) |next| { |
| 804 | atom = next; |
| 805 | } else { |
| 806 | // also pad with zeroes when last atom to ensure |
| 807 | // segments are aligned. |
| 808 | if (current_offset != segment.size) { |
| 809 | try writer.writeByteNTimes(0, segment.size - current_offset); |
| 810 | } |
| 811 | break; |
| 812 | } |
| 813 | } |
| 644 | 814 | } |
| 645 | 815 | |
| 646 | | try file.seekTo(file_offset + data_offset); |
| 647 | 816 | try writeVecSectionHeader( |
| 648 | 817 | file, |
| 649 | 818 | header_offset, |
| 650 | 819 | .data, |
| 651 | | @intCast(u32, (file_offset + data_offset) - header_offset - header_size), |
| 652 | | @intCast(u32, 1), // only 1 data section |
| 820 | @intCast(u32, (try file.getPos()) - header_offset - header_size), |
| 821 | @intCast(u32, segment_count), |
| 653 | 822 | ); |
| 654 | 823 | } |
| 655 | 824 | } |
| 656 | 825 | |
| 826 | fn emitLimits(writer: anytype, limits: wasm.Limits) !void { |
| 827 | try leb.writeULEB128(writer, @boolToInt(limits.max != null)); |
| 828 | try leb.writeULEB128(writer, limits.min); |
| 829 | if (limits.max) |max| { |
| 830 | try leb.writeULEB128(writer, max); |
| 831 | } |
| 832 | } |
| 833 | |
| 834 | fn emitInit(writer: anytype, init_expr: wasm.InitExpression) !void { |
| 835 | switch (init_expr) { |
| 836 | .i32_const => |val| { |
| 837 | try writer.writeByte(wasm.opcode(.i32_const)); |
| 838 | try leb.writeILEB128(writer, val); |
| 839 | }, |
| 840 | .i64_const => |val| { |
| 841 | try writer.writeByte(wasm.opcode(.i64_const)); |
| 842 | try leb.writeILEB128(writer, val); |
| 843 | }, |
| 844 | .f32_const => |val| { |
| 845 | try writer.writeByte(wasm.opcode(.f32_const)); |
| 846 | try writer.writeIntLittle(u32, @bitCast(u32, val)); |
| 847 | }, |
| 848 | .f64_const => |val| { |
| 849 | try writer.writeByte(wasm.opcode(.f64_const)); |
| 850 | try writer.writeIntLittle(u64, @bitCast(u64, val)); |
| 851 | }, |
| 852 | .global_get => |val| { |
| 853 | try writer.writeByte(wasm.opcode(.global_get)); |
| 854 | try leb.writeULEB128(writer, val); |
| 855 | }, |
| 856 | } |
| 857 | try writer.writeByte(wasm.opcode(.end)); |
| 858 | } |
| 859 | |
| 860 | fn emitImport(writer: anytype, import: wasm.Import) !void { |
| 861 | try leb.writeULEB128(writer, @intCast(u32, import.module_name.len)); |
| 862 | try writer.writeAll(import.module_name); |
| 863 | |
| 864 | try leb.writeULEB128(writer, @intCast(u32, import.name.len)); |
| 865 | try writer.writeAll(import.name); |
| 866 | |
| 867 | try writer.writeByte(@enumToInt(import.kind)); |
| 868 | switch (import.kind) { |
| 869 | .function => |type_index| try leb.writeULEB128(writer, type_index), |
| 870 | .global => |global_type| { |
| 871 | try leb.writeULEB128(writer, wasm.valtype(global_type.valtype)); |
| 872 | try writer.writeByte(@boolToInt(global_type.mutable)); |
| 873 | }, |
| 874 | .table => |table| { |
| 875 | try leb.writeULEB128(writer, wasm.reftype(table.reftype)); |
| 876 | try emitLimits(writer, table.limits); |
| 877 | }, |
| 878 | .memory => |limits| { |
| 879 | try emitLimits(writer, limits); |
| 880 | }, |
| 881 | } |
| 882 | } |
| 883 | |
| 657 | 884 | fn linkWithLLD(self: *Wasm, comp: *Compilation) !void { |
| 658 | 885 | const tracy = trace(@src()); |
| 659 | 886 | defer tracy.end(); |
| ... | ... | @@ -970,32 +1197,6 @@ fn linkWithLLD(self: *Wasm, comp: *Compilation) !void { |
| 970 | 1197 | } |
| 971 | 1198 | } |
| 972 | 1199 | |
| 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 | 1200 | fn reserveVecSectionHeader(file: fs.File) !u64 { |
| 1000 | 1201 | // section id + fixed leb contents size + fixed leb vector length |
| 1001 | 1202 | const header_size = 1 + 5 + 5; |
| ... | ... | @@ -1012,3 +1213,36 @@ fn writeVecSectionHeader(file: fs.File, offset: u64, section: wasm.Section, size |
| 1012 | 1213 | leb.writeUnsignedFixed(5, buf[6..], items); |
| 1013 | 1214 | try file.pwriteAll(&buf, offset); |
| 1014 | 1215 | } |
| 1216 | |
| 1217 | /// Searches for an a matching function signature, when not found |
| 1218 | /// a new entry will be made. The index of the existing/new signature will be returned. |
| 1219 | pub fn putOrGetFuncType(self: *Wasm, func_type: wasm.Type) !u32 { |
| 1220 | var index: u32 = 0; |
| 1221 | while (index < self.func_types.items.len) : (index += 1) { |
| 1222 | if (self.func_types.items[index].eql(func_type)) return index; |
| 1223 | } |
| 1224 | |
| 1225 | // functype does not exist. |
| 1226 | const params = try self.base.allocator.dupe(wasm.Valtype, func_type.params); |
| 1227 | errdefer self.base.allocator.free(params); |
| 1228 | const returns = try self.base.allocator.dupe(wasm.Valtype, func_type.returns); |
| 1229 | errdefer self.base.allocator.free(returns); |
| 1230 | try self.func_types.append(self.base.allocator, .{ |
| 1231 | .params = params, |
| 1232 | .returns = returns, |
| 1233 | }); |
| 1234 | return index; |
| 1235 | } |
| 1236 | |
| 1237 | /// From a given index and an `ExternalKind`, finds the corresponding Import. |
| 1238 | /// This is due to indexes for imports being unique per type, rather than across all imports. |
| 1239 | fn findImport(self: Wasm, index: u32, external_type: wasm.ExternalKind) ?*wasm.Import { |
| 1240 | var current_index: u32 = 0; |
| 1241 | for (self.imports.items) |*import| { |
| 1242 | if (import.kind == external_type) { |
| 1243 | if (current_index == index) return import; |
| 1244 | current_index += 1; |
| 1245 | } |
| 1246 | } |
| 1247 | return null; |
| 1248 | } |
Andrew Kelley <andrew@ziglang.org> 2021-11-27 12:17:32-08:00
GitHub <noreply@github.com> 2021-11-27 12:17:32-08:00
Signed by PGP key 4AEE18F83AFDEB23
lib