motiejus/zig
1
Fork 0
Code Releases Activity

wasm: Remove old DeclGen/genTypedValue

Browse Source
This commit is contained in:
Luuk de Gram
2022-03-06 16:54:56 +01:00
parent 70fc6e3776
commit 2faba4092a
1 changed files with 1 additions and 429 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
src/arch/wasm/CodeGen.zig
View File

@@ -639,7 +639,7 @@ fn resolveInst(self: *Self, ref: Air.Inst.Ref) InnerError!WValue {
}
// When we need to pass the value by reference (such as a struct), we will
// leverage `genTypedValue` to lower the constant to bytes and emit it
// leverage `generateSymbol` to lower the constant to bytes and emit it
// to the 'rodata' section. We then return the index into the section as `WValue`.
//
// In the other cases, we will simply lower the constant to a value that fits
@@ -903,434 +903,6 @@ pub fn genFunc(self: *Self) InnerError!void {
};
}
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),
/// 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;
}
fn target(self: *const DeclGen) std.Target {
return self.bin_file.base.options.target;
}
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.owner_decl;
var func_type = try genFunctype(self.gpa, ext_decl.ty, self.target());
defer 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 self.genTypedValue(decl.ty, init_val);
}
return Result{ .appended = {} };
}
}
/// Generates the wasm bytecode for the declaration belonging to `Context`
pub fn genTypedValue(self: *DeclGen, ty: Type, val: Value) InnerError!Result {
log.debug("genTypedValue: ty = {}, val = {}", .{ ty, val });
const writer = self.code.writer();
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.owner_decl,
.function => val.castTag(.function).?.data.owner_decl,
else => unreachable,
};
return try self.lowerDeclRefValue(ty, val, fn_decl, 0);
},
.Optional => {
var opt_buf: Type.Payload.ElemType = undefined;
const payload_type = ty.optionalChild(&opt_buf);
const is_pl = !val.isNull();
const abi_size = @intCast(usize, ty.abiSize(self.target()));
const offset = abi_size - @intCast(usize, payload_type.abiSize(self.target()));
if (!payload_type.hasRuntimeBits()) {
try writer.writeByteNTimes(@boolToInt(is_pl), abi_size);
return Result{ .appended = {} };
}
if (ty.isPtrLikeOptional()) {
if (val.castTag(.opt_payload)) |payload| {
return self.genTypedValue(payload_type, payload.data);
} else if (!val.isNull()) {
return self.genTypedValue(payload_type, val);
} else {
try writer.writeByteNTimes(0, abi_size);
return Result{ .appended = {} };
}
}
// `null-tag` bytes
try writer.writeByteNTimes(@boolToInt(is_pl), offset);
switch (try self.genTypedValue(
payload_type,
if (val.castTag(.opt_payload)) |pl| pl.data else Value.initTag(.undef),
)) {
.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)) {
.appended => {},
.externally_managed => |data| try writer.writeAll(data),
}
}
return Result{ .appended = {} };
},
.repeated => {
const array = val.castTag(.repeated).?.data;
const elem_ty = ty.childType();
const sentinel = ty.sentinel();
const len = ty.arrayLen();
var index: u32 = 0;
while (index < len) : (index += 1) {
switch (try self.genTypedValue(elem_ty, array)) {
.externally_managed => |data| try writer.writeAll(data),
.appended => {},
}
}
if (sentinel) |sentinel_value| {
return self.genTypedValue(elem_ty, sentinel_value);
}
return Result{ .appended = {} };
},
.empty_array_sentinel => {
const elem_ty = ty.childType();
const sent_val = ty.sentinel().?;
return self.genTypedValue(elem_ty, sent_val);
},
else => unreachable,
},
.Int => {
const info = ty.intInfo(self.target());
const abi_size = @intCast(usize, ty.abiSize(self.target()));
if (info.bits <= 64) {
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 = {} };
}
var space: Value.BigIntSpace = undefined;
const bigint = val.toBigInt(&space);
const iterations = @divExact(abi_size, @sizeOf(usize));
for (bigint.limbs) |_, index| {
const limb = bigint.limbs[bigint.limbs.len - index - 1];
try writer.writeIntLittle(usize, limb);
} else if (bigint.limbs.len < iterations) {
// When the value is saved in less limbs than the required
// abi size, we fill the remaining parts with 0's.
var it_left = iterations - bigint.limbs.len;
while (it_left > 0) {
it_left -= 1;
try writer.writeIntLittle(usize, 0);
}
}
return Result{ .appended = {} };
},
.Float => {
const float_bits = ty.floatBits(self.target());
if (float_bits > 64) {
return self.fail("Wasm TODO: Implement f80 and f128", .{});
}
switch (float_bits) {
16, 32 => try writer.writeIntLittle(u32, @bitCast(u32, val.toFloat(f32))),
64 => try writer.writeIntLittle(u64, @bitCast(u64, val.toFloat(f64))),
else => unreachable,
}
return Result{ .appended = {} };
},
.Enum => {
var int_buffer: Value.Payload.U64 = undefined;
const int_val = val.enumToInt(ty, &int_buffer);
var buf: Type.Payload.Bits = undefined;
const int_ty = ty.intTagType(&buf);
return self.genTypedValue(int_ty, int_val);
},
.Bool => {
try writer.writeByte(@boolToInt(val.toBool()));
return Result{ .appended = {} };
},
.Struct => {
const struct_obj = ty.castTag(.@"struct").?.data;
if (struct_obj.layout == .Packed) {
return self.fail("TODO: Packed structs for wasm", .{});
}
const struct_begin = self.code.items.len;
const field_vals = val.castTag(.@"struct").?.data;
for (field_vals) |field_val, index| {
const field_ty = ty.structFieldType(index);
if (!field_ty.hasRuntimeBits()) continue;
switch (try self.genTypedValue(field_ty, field_val)) {
.appended => {},
.externally_managed => |payload| try writer.writeAll(payload),
}
const unpadded_field_len = self.code.items.len - struct_begin;
// Pad struct members if required
const padded_field_end = ty.structFieldOffset(index + 1, self.target());
const padding = try std.math.cast(usize, padded_field_end - unpadded_field_len);
if (padding > 0) {
try writer.writeByteNTimes(0, padding);
}
}
return Result{ .appended = {} };
},
.Union => {
const union_val = val.castTag(.@"union").?.data;
const layout = ty.unionGetLayout(self.target());
if (layout.payload_size == 0) {
return self.genTypedValue(ty.unionTagType().?, union_val.tag);
}
// Check if we should store the tag first, in which case, do so now:
if (layout.tag_align >= layout.payload_align) {
switch (try self.genTypedValue(ty.unionTagType().?, union_val.tag)) {
.appended => {},
.externally_managed => |payload| try writer.writeAll(payload),
}
}
const union_ty = ty.cast(Type.Payload.Union).?.data;
const field_index = union_ty.tag_ty.enumTagFieldIndex(union_val.tag).?;
assert(union_ty.haveFieldTypes());
const field_ty = union_ty.fields.values()[field_index].ty;
if (!field_ty.hasRuntimeBits()) {
try writer.writeByteNTimes(0xaa, @intCast(usize, layout.payload_size));
} else {
switch (try self.genTypedValue(field_ty, union_val.val)) {
.appended => {},
.externally_managed => |payload| try writer.writeAll(payload),
}
// Unions have the size of the largest field, so we must pad
// whenever the active field has a smaller size.
const diff = layout.payload_size - field_ty.abiSize(self.target());
if (diff > 0) {
try writer.writeByteNTimes(0xaa, @intCast(usize, diff));
}
}
if (layout.tag_size == 0) {
return Result{ .appended = {} };
}
return self.genTypedValue(union_ty.tag_ty, union_val.tag);
},
.Pointer => switch (val.tag()) {
.variable => {
const decl = val.castTag(.variable).?.data.owner_decl;
return self.lowerDeclRefValue(ty, val, decl, 0);
},
.decl_ref => {
const decl = val.castTag(.decl_ref).?.data;
return self.lowerDeclRefValue(ty, val, decl, 0);
},
.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 writer.writeAll(data),
.appended => {},
}
switch (try self.genTypedValue(Type.usize, slice.len)) {
.externally_managed => |data| try writer.writeAll(data),
.appended => {},
}
return Result{ .appended = {} };
},
.zero => {
try writer.writeByteNTimes(0, @divExact(self.target().cpu.arch.ptrBitWidth(), 8));
return Result{ .appended = {} };
},
.elem_ptr => {
const elem_ptr = val.castTag(.elem_ptr).?.data;
const elem_size = ty.childType().abiSize(self.target());
const offset = elem_ptr.index * elem_size;
return self.lowerParentPtr(elem_ptr.array_ptr, @intCast(usize, offset));
},
.int_u64 => return self.genTypedValue(Type.usize, val),
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 abi_align = ty.abiAlignment(self.target());
{
const err_val = if (!is_pl) val else Value.initTag(.zero);
const start = self.code.items.len;
switch (try self.genTypedValue(error_ty, err_val)) {
.externally_managed => |data| try writer.writeAll(data),
.appended => {},
}
const unpadded_end = self.code.items.len - start;
const padded_end = mem.alignForwardGeneric(usize, unpadded_end, abi_align);
const padding = padded_end - unpadded_end;
if (padding > 0) {
try writer.writeByteNTimes(0, padding);
}
}
if (payload_ty.hasRuntimeBits()) {
const start = self.code.items.len;
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 writer.writeAll(data),
.appended => {},
}
const unpadded_end = self.code.items.len - start;
const padded_end = mem.alignForwardGeneric(usize, unpadded_end, abi_align);
const padding = padded_end - unpadded_end;
if (padding > 0) {
try writer.writeByteNTimes(0, padding);
}
}
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 => |tag| return self.fail("TODO: Implement zig type codegen for type: '{s}'", .{tag}),
}
}
fn lowerParentPtr(self: *DeclGen, ptr_value: Value, offset: usize) InnerError!Result {
switch (ptr_value.tag()) {
.decl_ref => {
const decl = ptr_value.castTag(.decl_ref).?.data;
return self.lowerParentPtrDecl(ptr_value, decl, offset);
},
else => |tag| return self.fail("TODO: Implement lowerParentPtr for pointer value tag: {s}", .{tag}),
}
}
fn lowerParentPtrDecl(self: *DeclGen, ptr_val: Value, decl: *Module.Decl, offset: usize) InnerError!Result {
decl.markAlive();
var ptr_ty_payload: Type.Payload.ElemType = .{
.base = .{ .tag = .single_mut_pointer },
.data = decl.ty,
};
const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
return self.lowerDeclRefValue(ptr_ty, ptr_val, decl, offset);
}
fn lowerDeclRefValue(
self: *DeclGen,
ty: Type,
val: Value,
/// The target decl that is being pointed to
decl: *Module.Decl,
/// When lowering to an indexed pointer, we can specify the offset
/// which will then be used as 'addend' to the relocation.
offset: usize,
) InnerError!Result {
const writer = self.code.writer();
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 writer.writeAll(payload),
}
var slice_len: Value.Payload.U64 = .{
.base = .{ .tag = .int_u64 },
.data = val.sliceLen(),
};
return self.genTypedValue(Type.usize, Value.initPayload(&slice_len.base));
}
decl.markAlive();
if (decl.link.wasm.sym_index == 0) {
try writer.writeIntLittle(u32, 0);
} else {
try writer.writeIntLittle(u32, @intCast(u32, try self.bin_file.getDeclVAddr(
decl,
.{
.parent_atom_index = self.symbol_index,
.offset = self.code.items.len,
.addend = @intCast(u32, offset),
},
)));
}
return Result{ .appended = {} };
}
};
const CallWValues = struct {
args: []WValue,
return_value: WValue,