diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig index 372510e62c..1224d13fb4 100644 --- a/src/arch/wasm/CodeGen.zig +++ b/src/arch/wasm/CodeGen.zig @@ -542,10 +542,9 @@ locals: std.ArrayListUnmanaged(u8), target: std.Target, /// Represents the wasm binary file that is being linked. bin_file: *link.File.Wasm, -/// Table with the global error set. Consists of every error found in -/// the compiled code. Each error name maps to a `Module.ErrorInt` which is emitted -/// during codegen to determine the error value. -global_error_set: std.StringHashMapUnmanaged(Module.ErrorInt), +/// Reference to the Module that this decl is part of. +/// Used to find the error value. +module: *Module, /// List of MIR Instructions mir_instructions: std.MultiArrayList(Mir.Inst) = .{}, /// Contains extra data for MIR @@ -581,7 +580,7 @@ pub fn deinit(self: *Self) void { self.* = undefined; } -/// Sets `err_msg` on `Context` and returns `error.CodegemFail` which is caught in link/Wasm.zig +/// Sets `err_msg` on `CodeGen` and returns `error.CodegenFail` which is caught in link/Wasm.zig fn fail(self: *Self, comptime fmt: []const u8, args: anytype) InnerError { const src: LazySrcLoc = .{ .node_offset = 0 }; const src_loc = src.toSrcLoc(self.decl); @@ -674,50 +673,41 @@ fn addExtraAssumeCapacity(self: *Self, extra: anytype) error{OutOfMemory}!u32 { return result; } -/// Using a given `Type`, returns the corresponding wasm Valtype -fn typeToValtype(self: *Self, ty: Type) InnerError!wasm.Valtype { +/// Using a given `Type`, returns the corresponding type +fn typeToValtype(ty: Type, target: std.Target) wasm.Valtype { return switch (ty.zigTypeTag()) { .Float => blk: { - const bits = ty.floatBits(self.target); + const bits = ty.floatBits(target); if (bits == 16 or bits == 32) break :blk wasm.Valtype.f32; if (bits == 64) break :blk wasm.Valtype.f64; - return self.fail("Float bit size not supported by wasm: '{d}'", .{bits}); + return wasm.Valtype.i32; // represented as pointer to stack }, .Int => blk: { - const info = ty.intInfo(self.target); + const info = ty.intInfo(target); if (info.bits <= 32) break :blk wasm.Valtype.i32; if (info.bits > 32 and info.bits <= 64) break :blk wasm.Valtype.i64; break :blk wasm.Valtype.i32; // represented as pointer to stack }, .Enum => switch (ty.tag()) { .enum_simple => wasm.Valtype.i32, - else => self.typeToValtype(ty.cast(Type.Payload.EnumFull).?.data.tag_ty), + else => typeToValtype(ty.cast(Type.Payload.EnumFull).?.data.tag_ty, target), }, - .Bool, - .Pointer, - .ErrorSet, - .Struct, - .ErrorUnion, - .Optional, - .Fn, - .Array, - => wasm.Valtype.i32, - else => self.fail("TODO - Wasm typeToValtype for type '{}'", .{ty}), + else => wasm.Valtype.i32, // all represented as reference/immediate }; } /// Using a given `Type`, returns the byte representation of its wasm value type -fn genValtype(self: *Self, ty: Type) InnerError!u8 { - return wasm.valtype(try self.typeToValtype(ty)); +fn genValtype(ty: Type, target: std.Target) u8 { + return wasm.valtype(typeToValtype(ty, target)); } /// Using a given `Type`, returns the corresponding wasm value type /// Differently from `genValtype` this also allows `void` to create a block /// with no return type -fn genBlockType(self: *Self, ty: Type) InnerError!u8 { +fn genBlockType(ty: Type, target: std.Target) u8 { return switch (ty.tag()) { .void, .noreturn => wasm.block_empty, - else => self.genValtype(ty), + else => genValtype(ty, target), }; } @@ -739,7 +729,7 @@ fn emitWValue(self: *Self, value: WValue) InnerError!void { /// Returns a corresponding `Wvalue` with `local` as active tag fn allocLocal(self: *Self, ty: Type) InnerError!WValue { const initial_index = self.local_index; - const valtype = try self.genValtype(ty); + const valtype = genValtype(ty, self.target); try self.locals.append(self.gpa, valtype); self.local_index += 1; return WValue{ .local = initial_index }; @@ -747,33 +737,33 @@ fn allocLocal(self: *Self, ty: Type) InnerError!WValue { /// Generates a `wasm.Type` from a given function type. /// Memory is owned by the caller. -fn genFunctype(self: *Self, fn_ty: Type) !wasm.Type { - var params = std.ArrayList(wasm.Valtype).init(self.gpa); +fn genFunctype(gpa: Allocator, fn_ty: Type, target: std.Target) !wasm.Type { + var params = std.ArrayList(wasm.Valtype).init(gpa); defer params.deinit(); - var returns = std.ArrayList(wasm.Valtype).init(self.gpa); + var returns = std.ArrayList(wasm.Valtype).init(gpa); defer returns.deinit(); const return_type = fn_ty.fnReturnType(); - const want_sret = self.isByRef(return_type); + const want_sret = isByRef(return_type, target); if (want_sret) { - try params.append(try self.typeToValtype(Type.usize)); + try params.append(typeToValtype(return_type, target)); } // param types if (fn_ty.fnParamLen() != 0) { - const fn_params = try self.gpa.alloc(Type, fn_ty.fnParamLen()); - defer self.gpa.free(fn_params); + const fn_params = try gpa.alloc(Type, fn_ty.fnParamLen()); + defer gpa.free(fn_params); fn_ty.fnParamTypes(fn_params); for (fn_params) |param_type| { if (!param_type.hasCodeGenBits()) continue; - try params.append(try self.typeToValtype(param_type)); + try params.append(typeToValtype(param_type, target)); } } // return type if (!want_sret and return_type.hasCodeGenBits()) { - try returns.append(try self.typeToValtype(return_type)); + try returns.append(typeToValtype(return_type, target)); } return wasm.Type{ @@ -782,8 +772,8 @@ fn genFunctype(self: *Self, fn_ty: Type) !wasm.Type { }; } -pub fn genFunc(self: *Self) InnerError!Result { - var func_type = try self.genFunctype(self.decl.ty); +pub fn genFunc(self: *Self) InnerError!void { + var func_type = try genFunctype(self.gpa, self.decl.ty, self.target); defer func_type.deinit(self.gpa); self.decl.fn_link.wasm.type_index = try self.bin_file.putOrGetFuncType(func_type); @@ -828,240 +818,260 @@ pub fn genFunc(self: *Self) InnerError!Result { }, else => |e| return e, }; - - // codegen data has been appended to `code` - return Result.appended; } -pub fn genDecl(self: *Self) InnerError!Result { - const decl = self.decl; - assert(decl.has_tv); +pub const DeclGen = struct { + /// The decl we are generating code for. + decl: *Decl, + /// The symbol we're generating code for. + /// This can either be the symbol of the Decl itself, + /// or one of its locals. + symbol_index: u32, + gpa: Allocator, + /// A reference to the linker, that will process the decl's + /// code and create any relocations it deems neccesary. + bin_file: *link.File.Wasm, + /// This will be set when `InnerError` has been returned. + /// In any other case, this will be 'undefined'. + err_msg: *Module.ErrorMsg, + /// Reference to the Module that is being compiled. + /// Used to find the error value of an error. + module: *Module, + /// The list of bytes that have been generated so far, + /// can be used to calculate the offset into a section. + code: *std.ArrayList(u8), - log.debug("gen: {s} type: {}, value: {}", .{ decl.name, decl.ty, decl.val }); - - if (decl.val.castTag(.function)) |func_payload| { - _ = func_payload; - return self.fail("TODO wasm backend genDecl function pointer", .{}); - } else if (decl.val.castTag(.extern_fn)) |extern_fn| { - const ext_decl = extern_fn.data; - var func_type = try self.genFunctype(ext_decl.ty); - func_type.deinit(self.gpa); - ext_decl.fn_link.wasm.type_index = try self.bin_file.putOrGetFuncType(func_type); - return Result.appended; - } else { - const init_val = if (decl.val.castTag(.variable)) |payload| init_val: { - break :init_val payload.data.init; - } else decl.val; - if (init_val.tag() != .unreachable_value) { - return try self.genTypedValue(decl.ty, init_val); - } - return Result.appended; + /// Sets `err_msg` on `DeclGen` and returns `error.CodegenFail` which is caught in link/Wasm.zig + fn fail(self: *DeclGen, comptime fmt: []const u8, args: anytype) InnerError { + const src: LazySrcLoc = .{ .node_offset = 0 }; + const src_loc = src.toSrcLoc(self.decl); + self.err_msg = try Module.ErrorMsg.create(self.gpa, src_loc, fmt, args); + return error.CodegenFail; } -} -/// Generates the wasm bytecode for the declaration belonging to `Context` -fn genTypedValue(self: *Self, ty: Type, val: Value) InnerError!Result { - if (val.isUndef()) { - try self.code.appendNTimes(0xaa, @intCast(usize, ty.abiSize(self.target))); - return Result.appended; + fn target(self: *const DeclGen) std.Target { + return self.bin_file.base.options.target; } - switch (ty.zigTypeTag()) { - .Fn => { - const fn_decl = switch (val.tag()) { - .extern_fn => val.castTag(.extern_fn).?.data, - .function => val.castTag(.function).?.data.owner_decl, - else => unreachable, - }; - return try self.lowerDeclRef(ty, val, fn_decl); - }, - .Optional => { - var opt_buf: Type.Payload.ElemType = undefined; - const payload_type = ty.optionalChild(&opt_buf); - if (ty.isPtrLikeOptional()) { - if (val.castTag(.opt_payload)) |payload| { - return try self.genTypedValue(payload_type, payload.data); - } else if (!val.isNull()) { - return try self.genTypedValue(payload_type, val); - } else { - try self.code.appendNTimes(0, @intCast(usize, ty.abiSize(self.target))); - return Result.appended; - } - } - // `null-tag` byte - try self.code.appendNTimes(@boolToInt(!val.isNull()), 4); - const pl_result = try self.genTypedValue( - payload_type, - if (val.castTag(.opt_payload)) |pl| pl.data else Value.initTag(.undef), - ); - switch (pl_result) { - .appended => {}, - .externally_managed => |payload| try self.code.appendSlice(payload), + + pub fn genDecl(self: *DeclGen) InnerError!Result { + const decl = self.decl; + assert(decl.has_tv); + + log.debug("gen: {s} type: {}, value: {}", .{ decl.name, decl.ty, decl.val }); + + if (decl.val.castTag(.function)) |func_payload| { + _ = func_payload; + return self.fail("TODO wasm backend genDecl function pointer", .{}); + } else if (decl.val.castTag(.extern_fn)) |extern_fn| { + const ext_decl = extern_fn.data; + var func_type = try genFunctype(self.gpa, ext_decl.ty, self.target()); + func_type.deinit(self.gpa); + ext_decl.fn_link.wasm.type_index = try self.bin_file.putOrGetFuncType(func_type); + return Result.appended; + } else { + const init_val = if (decl.val.castTag(.variable)) |payload| init_val: { + break :init_val payload.data.init; + } else decl.val; + if (init_val.tag() != .unreachable_value) { + return try self.genTypedValue(decl.ty, init_val, self.code.writer()); } return Result.appended; - }, - .Array => switch (val.tag()) { - .bytes => { - const payload = val.castTag(.bytes).?; - return Result{ .externally_managed = payload.data }; + } + } + + /// Generates the wasm bytecode for the declaration belonging to `Context` + fn genTypedValue(self: *DeclGen, ty: Type, val: Value, writer: anytype) InnerError!Result { + if (val.isUndef()) { + try writer.writeByteNTimes(0xaa, @intCast(usize, ty.abiSize(self.target()))); + return Result.appended; + } + switch (ty.zigTypeTag()) { + .Fn => { + const fn_decl = switch (val.tag()) { + .extern_fn => val.castTag(.extern_fn).?.data, + .function => val.castTag(.function).?.data.owner_decl, + else => unreachable, + }; + return try self.lowerDeclRef(ty, val, fn_decl, writer); }, - .array => { - const elem_vals = val.castTag(.array).?.data; - const elem_ty = ty.childType(); - for (elem_vals) |elem_val| { - switch (try self.genTypedValue(elem_ty, elem_val)) { + .Optional => { + var opt_buf: Type.Payload.ElemType = undefined; + const payload_type = ty.optionalChild(&opt_buf); + const is_pl = !val.isNull(); + + if (!payload_type.hasCodeGenBits()) { + try writer.writeByteNTimes(@boolToInt(is_pl), 4); + return Result.appended; + } + + if (ty.isPtrLikeOptional()) { + if (val.castTag(.opt_payload)) |payload| { + return try self.genTypedValue(payload_type, payload.data, writer); + } else if (!val.isNull()) { + return try self.genTypedValue(payload_type, val, writer); + } else { + try writer.writeByteNTimes(0, @intCast(usize, ty.abiSize(self.target()))); + return Result.appended; + } + } + + // `null-tag` bytes + try writer.writeByteNTimes(@boolToInt(is_pl), 4); + const pl_result = try self.genTypedValue( + payload_type, + if (val.castTag(.opt_payload)) |pl| pl.data else Value.initTag(.undef), + writer, + ); + switch (pl_result) { + .appended => {}, + .externally_managed => |payload| try writer.writeAll(payload), + } + return Result.appended; + }, + .Array => switch (val.tag()) { + .bytes => { + const payload = val.castTag(.bytes).?; + return Result{ .externally_managed = payload.data }; + }, + .array => { + const elem_vals = val.castTag(.array).?.data; + const elem_ty = ty.childType(); + for (elem_vals) |elem_val| { + switch (try self.genTypedValue(elem_ty, elem_val, writer)) { + .appended => {}, + .externally_managed => |data| try writer.writeAll(data), + } + } + return Result.appended; + }, + else => return self.fail("TODO implement genTypedValue for array type value: {s}", .{@tagName(val.tag())}), + }, + .Int => { + const info = ty.intInfo(self.target()); + const abi_size = @intCast(usize, ty.abiSize(self.target())); + // todo: Implement integer sizes larger than 64bits + if (info.bits > 64) return self.fail("TODO: Implement genTypedValue for integer bit size: {d}", .{info.bits}); + var buf: [8]u8 = undefined; + if (info.signedness == .unsigned) { + std.mem.writeIntLittle(u64, &buf, val.toUnsignedInt()); + } else std.mem.writeIntLittle(i64, &buf, val.toSignedInt()); + try writer.writeAll(buf[0..abi_size]); + return Result.appended; + }, + .Enum => { + try writer.writeByteNTimes(0xaa, @intCast(usize, ty.abiSize(self.target()))); + return Result.appended; + }, + .Bool => { + try writer.writeByte(@boolToInt(val.toBool())); + return Result.appended; + }, + .Struct => { + const field_vals = val.castTag(.@"struct").?.data; + for (field_vals) |field_val, index| { + const field_ty = ty.structFieldType(index); + if (!field_ty.hasCodeGenBits()) continue; + switch (try self.genTypedValue(field_ty, field_val, writer)) { .appended => {}, - .externally_managed => |data| try self.code.appendSlice(data), + .externally_managed => |payload| try writer.writeAll(payload), } } return Result.appended; }, - else => return self.fail("TODO implement genTypedValue for array type value: {s}", .{@tagName(val.tag())}), - }, - .Int => { - const info = ty.intInfo(self.target); - const abi_size = @intCast(usize, ty.abiSize(self.target)); - // todo: Implement integer sizes larger than 64bits - if (info.bits > 64) return self.fail("TODO: Implement genTypedValue for integer bit size: {d}", .{info.bits}); - var buf: [8]u8 = undefined; - if (info.signedness == .unsigned) { - std.mem.writeIntLittle(u64, &buf, val.toUnsignedInt()); - } else std.mem.writeIntLittle(i64, &buf, val.toSignedInt()); - try self.code.appendSlice(buf[0..abi_size]); - return Result.appended; - }, - .Enum => { - const size = @intCast(usize, ty.abiSize(self.target)); - try self.code.appendNTimes(0xaa, size); - return Result.appended; - }, - .Bool => { - const int_byte: u8 = @boolToInt(val.toBool()); - try self.code.append(int_byte); - return Result.appended; - }, - .Struct => { - const field_vals = val.castTag(.@"struct").?.data; - for (field_vals) |field_val, index| { - const field_ty = ty.structFieldType(index); - if (!field_ty.hasCodeGenBits()) continue; - switch (try self.genTypedValue(field_ty, field_val)) { - .appended => {}, - .externally_managed => |payload| try self.code.appendSlice(payload), - } - } - return Result.appended; - }, - .Union => { - // TODO: Implement Union declarations - const abi_size = @intCast(usize, ty.abiSize(self.target)); - try self.code.appendNTimes(0xaa, abi_size); - return Result.appended; - }, - .Pointer => switch (val.tag()) { - .variable => { - const decl = val.castTag(.variable).?.data.owner_decl; - return try self.lowerDeclRef(ty, val, decl); + .Union => { + // TODO: Implement Union declarations + try writer.writeByteNTimes(0xaa, @intCast(usize, ty.abiSize(self.target()))); + return Result.appended; }, - .decl_ref => { - const decl = val.castTag(.decl_ref).?.data; - return try self.lowerDeclRef(ty, val, decl); + .Pointer => switch (val.tag()) { + .variable => { + const decl = val.castTag(.variable).?.data.owner_decl; + return try self.lowerDeclRef(ty, val, decl, writer); + }, + .decl_ref => { + const decl = val.castTag(.decl_ref).?.data; + return try self.lowerDeclRef(ty, val, decl, writer); + }, + .slice => { + const slice = val.castTag(.slice).?.data; + var buf: Type.SlicePtrFieldTypeBuffer = undefined; + const ptr_ty = ty.slicePtrFieldType(&buf); + switch (try self.genTypedValue(ptr_ty, slice.ptr, writer)) { + .externally_managed => |data| try writer.writeAll(data), + .appended => {}, + } + switch (try self.genTypedValue(Type.usize, slice.len, writer)) { + .externally_managed => |data| try writer.writeAll(data), + .appended => {}, + } + return Result.appended; + }, + else => return self.fail("TODO: Implement zig decl gen for pointer type value: '{s}'", .{@tagName(val.tag())}), }, - .slice => { - const slice = val.castTag(.slice).?.data; - var buf: Type.SlicePtrFieldTypeBuffer = undefined; - const ptr_ty = ty.slicePtrFieldType(&buf); - switch (try self.genTypedValue(ptr_ty, slice.ptr)) { - .externally_managed => |data| try self.code.appendSlice(data), + .ErrorUnion => { + const error_ty = ty.errorUnionSet(); + const payload_ty = ty.errorUnionPayload(); + const is_pl = val.errorUnionIsPayload(); + + const err_val = if (!is_pl) val else Value.initTag(.zero); + switch (try self.genTypedValue(error_ty, err_val, writer)) { + .externally_managed => |data| try writer.writeAll(data), .appended => {}, } - switch (try self.genTypedValue(Type.usize, slice.len)) { - .externally_managed => |data| try self.code.appendSlice(data), - .appended => {}, + + if (payload_ty.hasCodeGenBits()) { + const pl_val = if (val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef); + switch (try self.genTypedValue(payload_ty, pl_val, writer)) { + .externally_managed => |data| try writer.writeAll(data), + .appended => {}, + } + } + + return Result.appended; + }, + .ErrorSet => { + switch (val.tag()) { + .@"error" => { + const name = val.castTag(.@"error").?.data.name; + const kv = try self.module.getErrorValue(name); + try writer.writeIntLittle(u32, kv.value); + }, + else => { + try writer.writeByteNTimes(0, @intCast(usize, ty.abiSize(self.target()))); + }, } return Result.appended; }, - else => return self.fail("TODO: Implement zig decl gen for pointer type value: '{s}'", .{@tagName(val.tag())}), - }, - .ErrorUnion => { - const error_ty = ty.errorUnionSet(); - const payload_ty = ty.errorUnionPayload(); - const is_pl = val.errorUnionIsPayload(); - - const err_val = if (!is_pl) val else Value.initTag(.zero); - switch (try self.genTypedValue(error_ty, err_val)) { - .externally_managed => |data| try self.code.appendSlice(data), - .appended => {}, - } - - if (payload_ty.hasCodeGenBits()) { - const pl_val = if (val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef); - switch (try self.genTypedValue(payload_ty, pl_val)) { - .externally_managed => |data| try self.code.appendSlice(data), - .appended => {}, - } - } - - return Result.appended; - }, - .ErrorSet => { - switch (val.tag()) { - .@"error" => { - const name = val.castTag(.@"error").?.data.name; - const value = self.global_error_set.get(name).?; - try self.code.writer().writeIntLittle(u32, value); - }, - else => { - const abi_size = @intCast(usize, ty.abiSize(self.target)); - try self.code.appendNTimes(0, abi_size); - }, - } - return Result.appended; - }, - else => |tag| return self.fail("TODO: Implement zig type codegen for type: '{s}'", .{tag}), - } -} - -fn lowerDeclRef(self: *Self, ty: Type, val: Value, decl: *Module.Decl) InnerError!Result { - if (ty.isSlice()) { - var buf: Type.SlicePtrFieldTypeBuffer = undefined; - const slice_ty = ty.slicePtrFieldType(&buf); - switch (try self.genTypedValue(slice_ty, val)) { - .appended => {}, - .externally_managed => |payload| try self.code.appendSlice(payload), + else => |tag| return self.fail("TODO: Implement zig type codegen for type: '{s}'", .{tag}), } - var slice_len: Value.Payload.U64 = .{ - .base = .{ .tag = .int_u64 }, - .data = val.sliceLen(), - }; - return try self.genTypedValue(Type.usize, Value.initPayload(&slice_len.base)); } - const offset = @intCast(u32, self.code.items.len); - const atom = &self.decl.link.wasm; - const target_sym_index = decl.link.wasm.sym_index; - decl.markAlive(); - if (decl.ty.zigTypeTag() == .Fn) { - // We found a function pointer, so add it to our table, - // as function pointers are not allowed to be stored inside the data section, - // but rather in a function table which are called by index - try self.bin_file.addTableFunction(target_sym_index); - try atom.relocs.append(self.gpa, .{ - .index = target_sym_index, - .offset = offset, - .relocation_type = .R_WASM_TABLE_INDEX_I32, - }); - } else { - try atom.relocs.append(self.gpa, .{ - .index = target_sym_index, - .offset = offset, - .relocation_type = .R_WASM_MEMORY_ADDR_I32, - }); - } - const ptr_width = @intCast(usize, self.target.cpu.arch.ptrBitWidth() / 8); - try self.code.appendNTimes(0xaa, ptr_width); + fn lowerDeclRef(self: *DeclGen, ty: Type, val: Value, decl: *Module.Decl, writer: anytype) InnerError!Result { + if (ty.isSlice()) { + var buf: Type.SlicePtrFieldTypeBuffer = undefined; + const slice_ty = ty.slicePtrFieldType(&buf); + switch (try self.genTypedValue(slice_ty, val, writer)) { + .appended => {}, + .externally_managed => |payload| try writer.writeAll(payload), + } + var slice_len: Value.Payload.U64 = .{ + .base = .{ .tag = .int_u64 }, + .data = val.sliceLen(), + }; + return try self.genTypedValue(Type.usize, Value.initPayload(&slice_len.base), writer); + } - return Result.appended; -} + decl.markAlive(); + try writer.writeIntLittle(u32, try self.bin_file.getDeclVAddr( + self.decl, // The decl containing the source symbol index + decl.ty, // type we generate the address of + self.symbol_index, // source symbol index + decl.link.wasm.sym_index, // target symbol index + @intCast(u32, self.code.items.len), // offset + )); + return Result.appended; + } +}; const CallWValues = struct { args: []WValue, @@ -1086,7 +1096,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) InnerError!CallWValu const ret_ty = fn_ty.fnReturnType(); // Check if we store the result as a pointer to the stack rather than // by value - if (self.isByRef(ret_ty)) { + if (isByRef(ret_ty, self.target)) { // the sret arg will be passed as first argument, therefore we // set the `return_value` before allocating locals for regular args. result.return_value = .{ .local = self.local_index }; @@ -1213,8 +1223,8 @@ fn arch(self: *const Self) std.Target.Cpu.Arch { } /// For a given `Type`, will return true when the type will be passed -/// by reference, rather than by value. -fn isByRef(self: Self, ty: Type) bool { +/// by reference, rather than by value +fn isByRef(ty: Type, target: std.Target) bool { switch (ty.zigTypeTag()) { .Type, .ComptimeInt, @@ -1242,7 +1252,7 @@ fn isByRef(self: Self, ty: Type) bool { .Frame, .Union, => return ty.hasCodeGenBits(), - .Int => return if (ty.intInfo(self.target).bits > 64) true else false, + .Int => return if (ty.intInfo(target).bits > 64) true else false, .ErrorUnion => { const has_tag = ty.errorUnionSet().hasCodeGenBits(); const has_pl = ty.errorUnionPayload().hasCodeGenBits(); @@ -1470,7 +1480,7 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const child_type = self.air.typeOfIndex(inst).childType(); if (child_type.abiSize(self.target) == 0) return WValue{ .none = {} }; - if (self.isByRef(child_type)) { + if (isByRef(child_type, self.target)) { return self.return_value; } @@ -1487,7 +1497,7 @@ fn airRetLoad(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const ret_ty = self.air.typeOf(un_op).childType(); if (!ret_ty.hasCodeGenBits()) return WValue.none; - if (!self.isByRef(ret_ty)) { + if (!isByRef(ret_ty, self.target)) { const result = try self.load(operand, ret_ty, 0); try self.emitWValue(result); } @@ -1509,7 +1519,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index) InnerError!WValue { else => unreachable, }; const ret_ty = fn_ty.fnReturnType(); - const first_param_sret = self.isByRef(ret_ty); + const first_param_sret = isByRef(ret_ty, self.target); const target: ?*Decl = blk: { const func_val = self.air.value(pl_op.operand) orelse break :blk null; @@ -1546,7 +1556,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const operand = try self.resolveInst(pl_op.operand); try self.emitWValue(operand); - var fn_type = try self.genFunctype(fn_ty); + var fn_type = try genFunctype(self.gpa, fn_ty, self.target); defer fn_type.deinit(self.gpa); const fn_type_index = try self.bin_file.putOrGetFuncType(fn_type); @@ -1642,7 +1652,7 @@ fn store(self: *Self, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErro } try self.emitWValue(lhs); try self.emitWValue(rhs); - const valtype = try self.typeToValtype(ty); + const valtype = typeToValtype(ty, self.target); // check if we should pass by pointer or value based on ABI size // TODO: Implement a way to get ABI values from a given type, // that is portable across the backend, rather than copying logic. @@ -1675,7 +1685,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) InnerError!WValue { if (!ty.hasCodeGenBits()) return WValue{ .none = {} }; - if (self.isByRef(ty)) { + if (isByRef(ty, self.target)) { const new_local = try self.allocStack(ty); try self.store(new_local, operand, ty, 0); return new_local; @@ -1712,7 +1722,7 @@ fn load(self: *Self, operand: WValue, ty: Type, offset: u32) InnerError!WValue { }; const opcode = buildOpcode(.{ - .valtype1 = try self.typeToValtype(ty), + .valtype1 = typeToValtype(ty, self.target), .width = abi_size * 8, // use bitsize instead of byte size .op = .load, .signedness = signedness, @@ -1743,7 +1753,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue { const rhs = try self.resolveInst(bin_op.rhs); const operand_ty = self.air.typeOfIndex(inst); - if (self.isByRef(operand_ty)) { + if (isByRef(operand_ty, self.target)) { return self.fail("TODO: Implement binary operation for type: {}", .{operand_ty}); } @@ -1753,7 +1763,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue { const bin_ty = self.air.typeOf(bin_op.lhs); const opcode: wasm.Opcode = buildOpcode(.{ .op = op, - .valtype1 = try self.typeToValtype(bin_ty), + .valtype1 = typeToValtype(bin_ty, self.target), .signedness = if (bin_ty.isSignedInt()) .signed else .unsigned, }); try self.addTag(Mir.Inst.Tag.fromOpcode(opcode)); @@ -1775,7 +1785,7 @@ fn airWrapBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue { const bin_ty = self.air.typeOf(bin_op.lhs); const opcode: wasm.Opcode = buildOpcode(.{ .op = op, - .valtype1 = try self.typeToValtype(bin_ty), + .valtype1 = typeToValtype(bin_ty, self.target), .signedness = if (bin_ty.isSignedInt()) .signed else .unsigned, }); try self.addTag(Mir.Inst.Tag.fromOpcode(opcode)); @@ -1924,8 +1934,8 @@ fn lowerConstant(self: *Self, val: Value, ty: Type) InnerError!WValue { }, .ErrorSet => switch (val.tag()) { .@"error" => { - const error_index = self.global_error_set.get(val.getError().?).?; - return WValue{ .imm32 = error_index }; + const kv = try self.module.getErrorValue(val.getError().?); + return WValue{ .imm32 = kv.value }; }, else => return WValue{ .imm32 = 0 }, }, @@ -1945,7 +1955,7 @@ fn lowerConstant(self: *Self, val: Value, ty: Type) InnerError!WValue { if (val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef), payload_type, ); - const pl_ptr = if (self.isByRef(payload_type)) + const pl_ptr = if (isByRef(payload_type, self.target)) try self.buildPointerOffset(result, error_type.abiSize(self.target), .new) else result; @@ -2159,8 +2169,8 @@ fn valueAsI32(self: Self, val: Value, ty: Type) i32 { .unsigned => return @bitCast(i32, @truncate(u32, val.toUnsignedInt())), }, .ErrorSet => { - const error_index = self.global_error_set.get(val.getError().?).?; - return @bitCast(i32, error_index); + const kv = self.module.getErrorValue(val.getError().?) catch unreachable; // passed invalid `Value` to function + return @bitCast(i32, kv.value); }, else => unreachable, // Programmer called this function for an illegal type } @@ -2168,7 +2178,7 @@ fn valueAsI32(self: Self, val: Value, ty: Type) i32 { fn airBlock(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const ty_pl = self.air.instructions.items(.data)[inst].ty_pl; - const block_ty = try self.genBlockType(self.air.getRefType(ty_pl.ty)); + const block_ty = genBlockType(self.air.getRefType(ty_pl.ty), self.target); const extra = self.air.extraData(Air.Block, ty_pl.payload); const body = self.air.extra[extra.end..][0..extra.data.body_len]; @@ -2265,7 +2275,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: std.math.CompareOperator) Inner // both lhs and rhs, as well as checking the payload are matching of lhs and rhs return self.cmpOptionals(lhs, rhs, operand_ty, op); } - } else if (self.isByRef(operand_ty)) { + } else if (isByRef(operand_ty, self.target)) { return self.cmpBigInt(lhs, rhs, operand_ty, op); } @@ -2280,7 +2290,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: std.math.CompareOperator) Inner break :blk operand_ty.intInfo(self.target).signedness; }; const opcode: wasm.Opcode = buildOpcode(.{ - .valtype1 = try self.typeToValtype(operand_ty), + .valtype1 = typeToValtype(operand_ty, self.target), .op = switch (op) { .lt => .lt, .lte => .le, @@ -2353,13 +2363,6 @@ fn airUnreachable(self: *Self, inst: Air.Inst.Index) InnerError!WValue { fn airBitcast(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const ty_op = self.air.instructions.items(.data)[inst].ty_op; const operand = try self.resolveInst(ty_op.operand); - // if (operand == .constant) { - // std.debug.print("Let's take a look at this!!!!!!\n--------------------\n", .{}); - // const result = try self.allocLocal(self.air.typeOfIndex(inst)); - // try self.emitWValue(operand); - // try self.addLabel(.local_set, result.local); - // return result; - // } return operand; } @@ -2407,7 +2410,7 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue { return self.fail("Field type '{}' too big to fit into stack frame", .{field_ty}); }; - if (self.isByRef(field_ty)) { + if (isByRef(field_ty, self.target)) { return self.buildPointerOffset(operand, offset, .new); } @@ -2527,7 +2530,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const val = try self.lowerConstant(case.values[0].value, target_ty); try self.emitWValue(val); const opcode = buildOpcode(.{ - .valtype1 = try self.typeToValtype(target_ty), + .valtype1 = typeToValtype(target_ty, self.target), .op = .ne, // not equal, because we want to jump out of this block if it does not match the condition. .signedness = signedness, }); @@ -2541,7 +2544,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const val = try self.lowerConstant(value.value, target_ty); try self.emitWValue(val); const opcode = buildOpcode(.{ - .valtype1 = try self.typeToValtype(target_ty), + .valtype1 = typeToValtype(target_ty, self.target), .op = .eq, .signedness = signedness, }); @@ -2596,7 +2599,7 @@ fn airUnwrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue const payload_ty = err_ty.errorUnionPayload(); if (!payload_ty.hasCodeGenBits()) return WValue{ .none = {} }; const offset = @intCast(u32, err_ty.errorUnionSet().abiSize(self.target)); - if (self.isByRef(payload_ty)) { + if (isByRef(payload_ty, self.target)) { return self.buildPointerOffset(operand, offset, .new); } return try self.load(operand, payload_ty, offset); @@ -2725,7 +2728,7 @@ fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const offset = opt_ty.abiSize(self.target) - payload_ty.abiSize(self.target); - if (self.isByRef(payload_ty)) { + if (isByRef(payload_ty, self.target)) { return self.buildPointerOffset(operand, offset, .new); } @@ -2856,7 +2859,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const result = try self.allocLocal(elem_ty); try self.addLabel(.local_set, result.local); - if (self.isByRef(elem_ty)) { + if (isByRef(elem_ty, self.target)) { return result; } return try self.load(result, elem_ty, 0); @@ -3017,7 +3020,7 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const result = try self.allocLocal(elem_ty); try self.addLabel(.local_set, result.local); - if (self.isByRef(elem_ty)) { + if (isByRef(elem_ty, self.target)) { return result; } return try self.load(result, elem_ty, 0); @@ -3064,7 +3067,7 @@ fn airPtrBinOp(self: *Self, inst: Air.Inst.Index, op: Op) InnerError!WValue { else => ptr_ty.childType(), }; - const valtype = try self.typeToValtype(Type.usize); + const valtype = typeToValtype(Type.usize, self.target); const mul_opcode = buildOpcode(.{ .valtype1 = valtype, .op = .mul }); const bin_opcode = buildOpcode(.{ .valtype1 = valtype, .op = op }); @@ -3167,7 +3170,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) InnerError!WValue { const result = try self.allocLocal(elem_ty); try self.addLabel(.local_set, result.local); - if (self.isByRef(elem_ty)) { + if (isByRef(elem_ty, self.target)) { return result; } return try self.load(result, elem_ty, 0); @@ -3184,8 +3187,8 @@ fn airFloatToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue { try self.emitWValue(operand); const op = buildOpcode(.{ .op = .trunc, - .valtype1 = try self.typeToValtype(dest_ty), - .valtype2 = try self.typeToValtype(op_ty), + .valtype1 = typeToValtype(dest_ty, self.target), + .valtype2 = typeToValtype(op_ty, self.target), .signedness = if (dest_ty.isSignedInt()) .signed else .unsigned, }); try self.addTag(Mir.Inst.Tag.fromOpcode(op)); @@ -3249,7 +3252,7 @@ fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std try self.emitWValue(lhs_pl); try self.emitWValue(rhs_pl); - const opcode = buildOpcode(.{ .op = .ne, .valtype1 = try self.typeToValtype(payload_ty) }); + const opcode = buildOpcode(.{ .op = .ne, .valtype1 = typeToValtype(payload_ty, self.target) }); try self.addTag(Mir.Inst.Tag.fromOpcode(opcode)); try self.addLabel(.br_if, 0); diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 23d0368d77..6e9e7bcbd2 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -234,12 +234,12 @@ pub fn updateFunc(self: *Wasm, module: *Module, func: *Module.Fn, air: Air, live .locals = .{}, .target = self.base.options.target, .bin_file = self, - .global_error_set = self.base.options.module.?.global_error_set, + .module = module, }; defer codegen.deinit(); // generate the 'code' section for the function declaration - const result = codegen.genFunc() catch |err| switch (err) { + codegen.genFunc() catch |err| switch (err) { error.CodegenFail => { decl.analysis = .codegen_failure; try module.failed_decls.put(module.gpa, decl, codegen.err_msg); @@ -247,7 +247,7 @@ pub fn updateFunc(self: *Wasm, module: *Module, func: *Module.Fn, air: Air, live }, else => |e| return e, }; - return self.finishUpdateDecl(decl, result, &codegen); + return self.finishUpdateDecl(decl, codegen.code.items); } // Generate code for the Decl, storing it in memory to be later written to @@ -264,40 +264,37 @@ pub fn updateDecl(self: *Wasm, module: *Module, decl: *Module.Decl) !void { decl.link.wasm.clear(); - var codegen: CodeGen = .{ + var code_writer = std.ArrayList(u8).init(self.base.allocator); + defer code_writer.deinit(); + var decl_gen: CodeGen.DeclGen = .{ .gpa = self.base.allocator, - .air = undefined, - .liveness = undefined, - .values = .{}, - .code = std.ArrayList(u8).init(self.base.allocator), .decl = decl, - .err_msg = undefined, - .locals = .{}, - .target = self.base.options.target, + .symbol_index = decl.link.wasm.sym_index, .bin_file = self, - .global_error_set = self.base.options.module.?.global_error_set, + .err_msg = undefined, + .code = &code_writer, + .module = module, }; - defer codegen.deinit(); // generate the 'code' section for the function declaration - const result = codegen.genDecl() catch |err| switch (err) { + const result = decl_gen.genDecl() catch |err| switch (err) { error.CodegenFail => { decl.analysis = .codegen_failure; - try module.failed_decls.put(module.gpa, decl, codegen.err_msg); + try module.failed_decls.put(module.gpa, decl, decl_gen.err_msg); return; }, else => |e| return e, }; - return self.finishUpdateDecl(decl, result, &codegen); -} - -fn finishUpdateDecl(self: *Wasm, decl: *Module.Decl, result: CodeGen.Result, codegen: *CodeGen) !void { - const code: []const u8 = switch (result) { - .appended => @as([]const u8, codegen.code.items), - .externally_managed => |payload| payload, + const code = switch (result) { + .externally_managed => |data| data, + .appended => code_writer.items, }; + return self.finishUpdateDecl(decl, code); +} + +fn finishUpdateDecl(self: *Wasm, decl: *Module.Decl, code: []const u8) !void { if (decl.isExtern()) { try self.addOrUpdateImport(decl); return; @@ -313,7 +310,7 @@ fn finishUpdateDecl(self: *Wasm, decl: *Module.Decl, result: CodeGen.Result, cod /// Creates a new local symbol for a given type (and its bytes it's represented by) /// and then append it as a 'contained' atom onto the Decl. -pub fn createLocalSymbol(self: *Wasm, decl: *Module.Decl, ty: Type, code: []const u8) !u32 { +pub fn createLocalSymbol(self: *Wasm, decl: *Module.Decl, ty: Type) !u32 { assert(ty.zigTypeTag() != .Fn); // cannot create local symbols for functions var symbol: Symbol = .{ .name = "unnamed_local", @@ -325,9 +322,7 @@ pub fn createLocalSymbol(self: *Wasm, decl: *Module.Decl, ty: Type, code: []cons symbol.setFlag(.WASM_SYM_VISIBILITY_HIDDEN); var atom = Atom.empty; - atom.size = @intCast(u32, code.len); atom.alignment = ty.abiAlignment(self.base.options.target); - try atom.code.appendSlice(self.base.allocator, code); if (self.symbols_free_list.popOrNull()) |index| { atom.sym_index = index; @@ -341,6 +336,41 @@ pub fn createLocalSymbol(self: *Wasm, decl: *Module.Decl, ty: Type, code: []cons return atom.sym_index; } +pub fn updateLocalSymbolCode(self: *Wasm, decl: *Module.Decl, symbol_index: u32, code: []const u8) !void { + const atom = decl.link.wasm.symbolAtom(symbol_index); + atom.size = @intCast(u32, code.len); + try atom.code.appendSlice(self.base.allocator, code); +} + +/// 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(self: *Wasm, decl: *Module.Decl, ty: Type, symbol_index: u32, target_symbol_index: u32, offset: u32) !u32 { + const atom = decl.link.wasm.symbolAtom(symbol_index); + const is_wasm32 = self.base.options.target.cpu.arch == .wasm32; + if (ty.zigTypeTag() == .Fn) { + // We found a function pointer, so add it to our table, + // as function pointers are not allowed to be stored inside the data section. + // They are instead stored in a function table which are called by index. + try self.addTableFunction(target_symbol_index); + try atom.relocs.append(self.base.allocator, .{ + .index = target_symbol_index, + .offset = offset, + .relocation_type = if (is_wasm32) .R_WASM_TABLE_INDEX_I32 else .R_WASM_TABLE_INDEX_I64, + }); + } else { + try atom.relocs.append(self.base.allocator, .{ + .index = target_symbol_index, + .offset = offset, + .relocation_type = if (is_wasm32) .R_WASM_MEMORY_ADDR_I32 else .R_WASM_MEMORY_ADDR_I64, + }); + } + // 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 updateDeclExports( self: *Wasm, module: *Module, diff --git a/src/link/Wasm/Atom.zig b/src/link/Wasm/Atom.zig index cabd9f1571..09fb6735f7 100644 --- a/src/link/Wasm/Atom.zig +++ b/src/link/Wasm/Atom.zig @@ -31,6 +31,10 @@ next: ?*Atom, /// is null when this atom is the first in its order prev: ?*Atom, +/// Contains atoms local to a decl, all managed by this `Atom`. +/// When the parent atom is being freed, it will also do so for all local atoms. +locals: std.ArrayListUnmanaged(Atom) = .{}, + /// Represents a default empty wasm `Atom` pub const empty: Atom = .{ .alignment = 0, @@ -45,6 +49,11 @@ pub const empty: Atom = .{ pub fn deinit(self: *Atom, gpa: Allocator) void { self.relocs.deinit(gpa); self.code.deinit(gpa); + + while (self.locals.popOrNull()) |*local| { + local.deinit(gpa); + } + self.locals.deinit(gpa); } /// Sets the length of relocations and code to '0', @@ -72,6 +81,15 @@ pub fn getFirst(self: *Atom) *Atom { return tmp; } +/// Returns the atom for the given `symbol_index`. +/// This can be either the `Atom` itself, or one of its locals. +pub fn symbolAtom(self: *Atom, symbol_index: u32) *Atom { + if (self.sym_index == symbol_index) return self; + return for (self.locals.items) |*local_atom| { + if (local_atom.sym_index == symbol_index) break local_atom; + } else unreachable; // Used a symbol index not present in this atom or its children. +} + /// Resolves the relocations within the atom, writing the new value /// at the calculated offset. pub fn resolveRelocs(self: *Atom, wasm_bin: *const Wasm) !void {