summaryrefslogtreecommitdiff
path: root/src/mods
diff options
context:
space:
mode:
Diffstat (limited to 'src/mods')
-rw-r--r--src/mods/Parser.zig98
-rw-r--r--src/mods/ir.zig7
-rw-r--r--src/mods/vm.zig179
3 files changed, 152 insertions, 132 deletions
diff --git a/src/mods/Parser.zig b/src/mods/Parser.zig
index 48a8225..544ef31 100644
--- a/src/mods/Parser.zig
+++ b/src/mods/Parser.zig
@@ -7,34 +7,10 @@ bytes: []const u8,
byte_idx: usize,
allocator: Allocator,
-// TODO: We don't really need ArrayLists
-types: std.ArrayListUnmanaged(Functype) = .{},
-imports: std.ArrayListUnmanaged(Import) = .{},
-exports: std.StringHashMapUnmanaged(u32) = .{},
-functions: std.ArrayListUnmanaged(u32) = .{},
+types: ?[]vm.Functype = null,
+functions: ?[]vm.Function = null,
memory: ?Memtype = null,
-code: std.ArrayListUnmanaged(Func) = .{},
-funcs: std.ArrayListUnmanaged(vm.Func) = .{},
-
-pub const FunctionType = struct {
- parameters: []u8,
- results: []u8,
-
- pub fn deinit(self: FunctionType, allocator: Allocator) void {
- allocator.free(self.parameters);
- allocator.free(self.results);
- }
-};
-
-pub const FunctionBody = struct {
- locals: []Local,
- code: []u8,
-};
-
-pub const FunctionScope = enum {
- external,
- internal,
-};
+exports: std.StringHashMapUnmanaged(u32) = .{},
const Parser = @This();
@@ -56,6 +32,7 @@ pub const Error = error{
invalid_importdesc,
invalid_exportdesc,
double_else,
+ duplicated_funcsec,
unresolved_branch,
unterminated_wasm,
};
@@ -172,11 +149,7 @@ pub fn parseReftype(self: *Parser) !std.wasm.RefType {
// NOTE: Parsing of Valtype can be improved but it makes it less close to spec so...
// TODO: Do we really need Valtype?
-pub const Valtype = union(enum) {
- val: std.wasm.Valtype,
- ref: std.wasm.RefType,
-};
-fn parseValtype(self: *Parser) !Valtype {
+fn parseValtype(self: *Parser) !vm.Valtype {
const pb = self.peek() orelse return Error.unterminated_wasm;
return switch (pb) {
0x7F, 0x7E, 0x7D, 0x7C => .{ .val = try self.parseNumtype() },
@@ -186,24 +159,15 @@ fn parseValtype(self: *Parser) !Valtype {
};
}
-fn parseResultType(self: *Parser) ![]Valtype {
+fn parseResultType(self: *Parser) ![]vm.Valtype {
return try self.parseVector(Parser.parseValtype);
}
-pub const Functype = struct {
- parameters: []Valtype,
- rt2: []Valtype,
-
- pub fn deinit(self: Functype, allocator: Allocator) void {
- allocator.free(self.parameters);
- allocator.free(self.rt2);
- }
-};
-fn parseFunctype(self: *Parser) !Functype {
+fn parseFunctype(self: *Parser) !vm.Functype {
if (try self.readByte() != 0x60) return Error.invalid_functype;
return .{
.parameters = try self.parseResultType(),
- .rt2 = try self.parseResultType(),
+ .returns = try self.parseResultType(),
};
}
@@ -245,7 +209,7 @@ fn parseTabletype(self: *Parser) !Tabletype {
}
const Globaltype = struct {
- t: Valtype,
+ t: vm.Valtype,
m: enum {
@"const",
@"var",
@@ -296,11 +260,7 @@ pub fn parseModule(self: *Parser) !vm.Module {
.max = self.memory.?.lim.max,
},
.exports = self.exports,
- .funcs = try self.funcs.toOwnedSlice(self.allocator),
- .types = try self.types.toOwnedSlice(self.allocator),
- .functions = try self.functions.toOwnedSlice(self.allocator),
- .imports = try self.imports.toOwnedSlice(self.allocator),
- .code = try self.code.toOwnedSlice(self.allocator),
+ .functions = self.functions.?,
};
}
@@ -315,10 +275,9 @@ fn parseTypesec(self: *Parser) !void {
const end_idx = self.byte_idx + size;
const ft = try self.parseVector(Parser.parseFunctype);
- // TODO: Maybe the interface should be better?
- try self.types.appendSlice(self.allocator, ft);
+ self.types = ft;
- // TODO: run this check not only on debug
+ // TODO(ernesto): run this check not only on debug
std.debug.assert(self.byte_idx == end_idx);
}
@@ -349,8 +308,9 @@ fn parseImportsec(self: *Parser) !void {
const size = try self.readU32();
const end_idx = self.byte_idx + size;
+ // TODO(ernesto): this should be used to do name resolution.
const imports = try self.parseVector(Parser.parseImport);
- try self.imports.appendSlice(self.allocator, imports);
+ _ = imports;
// TODO: run this check not only on debug
std.debug.assert(self.byte_idx == end_idx);
@@ -361,7 +321,16 @@ fn parseFuncsec(self: *Parser) !void {
const end_idx = self.byte_idx + size;
const types = try self.parseVector(Parser.readU32);
- try self.functions.appendSlice(self.allocator, types);
+
+ if (self.functions != null) return Error.duplicated_funcsec;
+ self.functions = try self.allocator.alloc(vm.Function, types.len);
+
+ for (types, 0..) |t, i| {
+ self.functions.?[i].func_type = self.types.?[t];
+ }
+
+ // TODO(ernesto): run this check not only in debug
+ std.debug.assert(types.len == self.functions.?.len);
// TODO: run this check not only on debug
std.debug.assert(self.byte_idx == end_idx);
@@ -446,13 +415,12 @@ fn parseElemsec(self: *Parser) !void {
}
pub const Func = struct {
- locals: []Valtype,
- code: []const u8,
+ locals: []vm.Valtype,
ir: IR,
};
const Local = struct {
n: u32,
- t: Valtype,
+ t: vm.Valtype,
};
fn parseLocal(self: *Parser) !Local {
return .{
@@ -476,8 +444,7 @@ fn parseCode(self: *Parser) !Func {
try ir.print(stdout);
const func = Func{
- .locals = try self.allocator.alloc(Valtype, local_count),
- .code = &.{},
+ .locals = try self.allocator.alloc(vm.Valtype, local_count),
.ir = ir,
};
@@ -498,10 +465,15 @@ fn parseCodesec(self: *Parser) !void {
const end_idx = self.byte_idx + size;
const codes = try self.parseVector(Parser.parseCode);
- for (codes, 0..) |_, i| {
- try self.funcs.append(self.allocator, .{ .internal = @intCast(i) });
+ // TODO: run this check not only on debug
+ std.debug.assert(codes.len == self.functions.?.len);
+
+ for (codes, self.functions.?) |code, *f| {
+ f.typ = .{ .internal = .{
+ .locals = code.locals,
+ .ir = code.ir,
+ } };
}
- try self.code.appendSlice(self.allocator, codes);
// TODO: run this check not only on debug
std.debug.assert(self.byte_idx == end_idx);
diff --git a/src/mods/ir.zig b/src/mods/ir.zig
index 25409e4..e745cb8 100644
--- a/src/mods/ir.zig
+++ b/src/mods/ir.zig
@@ -1,5 +1,6 @@
const std = @import("std");
const Parser = @import("Parser.zig");
+const vm = @import("vm.zig");
const Allocator = std.mem.Allocator;
@@ -44,7 +45,7 @@ opcodes: []Opcode,
indices: []Index,
// TODO: this could be a byte array and v128.const and i8x16.shuffle could live here too
-select_valtypes: []Parser.Valtype,
+select_valtypes: []vm.Valtype,
pub fn print(self: IR, writer: anytype) !void {
for (self.opcodes, 0..) |op, i| {
@@ -621,8 +622,8 @@ const IRParserState = struct {
fn parseExpression(self: *IRParserState) Parser.Error!void {
const b = try self.parser.readByte();
try switch (b) {
- 0x00 => {}, // TODO
- 0x01 => {},
+ 0x00 => self.push(@enumFromInt(b), .{ .u64 = 0 }),
+ 0x01 => self.push(@enumFromInt(b), .{ .u64 = 0 }),
0x02...0x03 => self.parseBlock(b),
0x04 => self.parseIf(),
0x0C...0x0D => self.parseBranch(b),
diff --git a/src/mods/vm.zig b/src/mods/vm.zig
index 413069f..4f4f5a6 100644
--- a/src/mods/vm.zig
+++ b/src/mods/vm.zig
@@ -9,29 +9,50 @@ pub const Memory = struct {
min: u32,
max: ?u32,
};
-// TODO: Resolve function calls at parse time
-// TODO: Resolve function types at compile time
-pub const Func = union(enum) {
- internal: u32,
- external: u32,
+
+pub const Valtype = union(enum) {
+ val: std.wasm.Valtype,
+ ref: std.wasm.RefType,
+};
+
+pub const Functype = struct {
+ parameters: []Valtype,
+ returns: []Valtype,
+
+ pub fn deinit(self: Functype, allocator: Allocator) void {
+ allocator.free(self.parameters);
+ allocator.free(self.returns);
+ }
};
+pub const Function = struct { func_type: Functype, typ: union(enum) {
+ internal: struct {
+ locals: []Valtype,
+ ir: IR,
+ },
+ external: void,
+} };
pub const Module = struct {
memory: Memory,
- funcs: []Func,
+ functions: []Function,
exports: std.StringHashMapUnmanaged(u32),
- imports: []Parser.Import,
- types: []Parser.Functype,
- functions: []u32,
- code: []Parser.Func,
fn deinit(self: *Module, allocator: Allocator) void {
self.exports.deinit(allocator);
- allocator.free(self.funcs);
- allocator.free(self.imports);
- allocator.free(self.types);
+ for (self.functions) |f| {
+ allocator.free(f.func_type.parameters);
+ allocator.free(f.func_type.returns);
+ switch (f.typ) {
+ .internal => {
+ allocator.free(f.typ.internal.ir.opcodes);
+ allocator.free(f.typ.internal.ir.indices);
+ allocator.free(f.typ.internal.ir.select_valtypes);
+ allocator.free(f.typ.internal.locals);
+ },
+ .external => {},
+ }
+ }
allocator.free(self.functions);
- allocator.free(self.code);
}
};
@@ -61,7 +82,7 @@ pub const Runtime = struct {
// if memory max is not set the memory is allowed to grow but it is not supported at the moment
const max = module.memory.max orelse 1_000;
if (module.memory.max == null) {
- std.debug.print("[WARN]: growing memory is not yet supported, usign a default value of 1Kb\n", .{});
+ std.log.warn("Growing memory is not yet supported, usign a default value of 1Kb\n", .{});
}
const memory = try allocator.alloc(u8, max);
return Runtime{
@@ -78,32 +99,78 @@ pub const Runtime = struct {
allocator.free(self.memory);
}
- pub fn executeFrame(self: *Runtime, _: Allocator, frame: *CallFrame) !void {
- loop: while (true) {
+ pub fn executeFrame(self: *Runtime, allocator: Allocator, frame: *CallFrame) !void {
+ loop: while (frame.program_counter < frame.code.opcodes.len) {
const opcode: IR.Opcode = frame.code.opcodes[frame.program_counter];
+ const index = frame.code.indices[frame.program_counter];
switch (opcode) {
+ // TODO(ernesto): How should we handle unreachable?
+ .@"unreachable" => {},
+ .nop => {},
.br => {
- // TODO(luccie-cmd): Branching like this is dangerous, we should do safety things or smth.
- frame.program_counter = frame.code.indices[frame.program_counter].u32 - 1;
+ frame.program_counter = index.u32;
+ continue;
},
.br_if => {
if (self.stack.pop().?.i32 != 0) {
- // TODO(luccie-cmd): Branching like this is dangerous, we should do safety things or smth.
- frame.program_counter = frame.code.indices[frame.program_counter].u32 - 1;
+ frame.program_counter = index.u32;
+ continue;
}
},
- .localget => {
- try self.stack.append(frame.locals[frame.code.indices[frame.program_counter].u32]);
+ .br_table => @panic("UNIMPLEMENTED"),
+ .@"return" => break :loop,
+ .call => {
+ // TODO: figure out how many parameters to push
+ try self.call(allocator, index.u32, &[_]Value{});
},
- .localset => {
- const a = self.stack.pop().?;
- frame.locals[frame.code.indices[frame.program_counter].u32] = a;
- },
- .localtee => {
- const a = self.stack.pop().?;
- try self.stack.append(a);
- frame.locals[frame.code.indices[frame.program_counter].u32] = a;
+ .call_indirect => @panic("UNIMPLEMENTED"),
+
+ .refnull => @panic("UNIMPLEMENTED"),
+ .refisnull => @panic("UNIMPLEMENTED"),
+ .reffunc => @panic("UNIMPLEMENTED"),
+
+ .drop => @panic("UNIMPLEMENTED"),
+ .select => @panic("UNIMPLEMENTED"),
+ .select_with_values => @panic("UNIMPLEMENTED"),
+
+ .localget => try self.stack.append(frame.locals[index.u32]),
+ .localset => frame.locals[index.u32] = self.stack.pop().?,
+ .localtee => frame.locals[index.u32] = self.stack.items[self.stack.items.len - 1],
+ .globalget => @panic("UNIMPLEMENTED"),
+ .globalset => @panic("UNIMPLEMENTED"),
+
+ .tableget => @panic("UNIMPLEMENTED"),
+ .tableset => @panic("UNIMPLEMENTED"),
+ .tableinit => @panic("UNIMPLEMENTED"),
+ .elemdrop => @panic("UNIMPLEMENTED"),
+ .tablecopy => @panic("UNIMPLEMENTED"),
+ .tablegrow => @panic("UNIMPLEMENTED"),
+ .tablesize => @panic("UNIMPLEMENTED"),
+ .tablefill => @panic("UNIMPLEMENTED"),
+
+ .i32_load => {
+ const start = index.memarg.alignment + index.memarg.offset;
+ const end = start + @sizeOf(i32);
+ try self.stack.append(.{ .i32 = std.mem.littleToNative(i32, std.mem.bytesAsValue(i32, self.memory[start..end]).*) });
},
+ // 0x28 => {
+ // const address = leb128Decode(u32, frame.code[frame.program_counter..]);
+ // frame.program_counter += address.len;
+ // const offset = leb128Decode(u32, frame.code[frame.program_counter..]);
+ // frame.program_counter += offset.len;
+ // const start = (address.val + offset.val);
+ // const end = start + @sizeOf(u32);
+ // try self.stack.append(Value{ .i32 = decodeLittleEndian(i32, self.memory[start..end]) });
+ // },
+ // 0x29 => {
+ // const address = leb128Decode(u32, frame.code[frame.program_counter..]);
+ // frame.program_counter += address.len;
+ // const offset = leb128Decode(u32, frame.code[frame.program_counter..]);
+ // frame.program_counter += offset.len;
+ // const start = (address.val + offset.val);
+ // const end = start + @sizeOf(u64);
+ // try self.stack.append(Value{ .i64 = decodeLittleEndian(i64, self.memory[start..end]) });
+
.i32_const => {
try self.stack.append(Value{ .i32 = frame.code.indices[frame.program_counter].i32 });
},
@@ -141,9 +208,6 @@ pub const Runtime = struct {
.i64_extend_i32_u => {
try self.stack.append(.{ .i64 = self.stack.pop().?.i32 });
},
- .@"return" => {
- break :loop;
- },
else => {
std.log.err("instruction {any} not implemented\n", .{opcode});
std.process.exit(1);
@@ -592,14 +656,11 @@ pub const Runtime = struct {
// else => std.log.err("instruction {} not implemented\n", .{byte}),
// }
frame.program_counter += 1;
- if (frame.program_counter >= frame.code.opcodes.len) {
- break :loop;
- }
}
}
- // TODO: Do name resolution
- pub fn callExternal(self: *Runtime, allocator: Allocator, name: []const u8, parameters: []usize) !void {
+ // TODO: Do name resolution at parseTime
+ pub fn callExternal(self: *Runtime, allocator: Allocator, name: []const u8, parameters: []Value) !void {
if (self.module.exports.get(name)) |function| {
try self.call(allocator, function, parameters);
} else {
@@ -607,36 +668,21 @@ pub const Runtime = struct {
}
}
- pub fn call(self: *Runtime, allocator: Allocator, function: usize, parameters: []usize) AllocationError!void {
- const f = self.module.funcs[function];
- switch (f) {
+ pub fn call(self: *Runtime, allocator: Allocator, function: usize, parameters: []Value) AllocationError!void {
+ const f = self.module.functions[function];
+ switch (f.typ) {
.internal => {
- const ir: IR = self.module.code[f.internal].ir;
- const function_type = self.module.types[self.module.functions[f.internal]];
+ const ir: IR = f.typ.internal.ir;
+ const function_type = f.func_type;
var frame = CallFrame{
.code = ir,
.program_counter = 0x0,
- .locals = try allocator.alloc(Value, self.module.code[f.internal].locals.len + function_type.parameters.len),
+ .locals = try allocator.alloc(Value, f.typ.internal.locals.len + function_type.parameters.len),
};
- for (parameters, 0..) |p, i| {
- switch (function_type.parameters[i]) {
- .val => |v| switch (v) {
- .i32 => {
- std.debug.print("Local with type i32\n", .{});
- frame.locals[i] = .{ .i32 = @intCast(p) };
- },
- .i64 => {
- std.debug.print("Local with type i64\n", .{});
- frame.locals[i] = .{ .i64 = @intCast(p) };
- },
- else => unreachable,
- },
- .ref => unreachable,
- }
- }
+ @memcpy(frame.locals[0..parameters.len], parameters);
- for (self.module.code[f.internal].locals, function_type.parameters.len..) |local, i| {
+ for (f.typ.internal.locals, function_type.parameters.len..) |local, i| {
switch (local) {
.val => |v| switch (v) {
.i32 => {
@@ -658,10 +704,11 @@ pub const Runtime = struct {
allocator.free(frame.locals);
},
.external => {
- const name = self.module.imports[f.external].name;
- if (self.global_runtime.functions.get(name)) |external| {
- external(&self.stack);
- }
+ // TODO(ernesto): handle external functions
+ // const name = self.module.imports[f.external].name;
+ // if (self.global_runtime.functions.get(name)) |external| {
+ // external(&self.stack);
+ // }
},
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-14 19:25:56 +0000