1284 lines
44 KiB
Zig
1284 lines
44 KiB
Zig
const std = @import("std");
|
|
const Ast = @import("Ast.zig");
|
|
const Ir = @import("Ir.zig");
|
|
const Story = @import("Story.zig");
|
|
const compile = @import("compile.zig");
|
|
const InternPool = compile.InternPool;
|
|
const Module = compile.Module;
|
|
const assert = std.debug.assert;
|
|
const Sema = @This();
|
|
|
|
gpa: std.mem.Allocator,
|
|
arena: std.mem.Allocator,
|
|
module: *compile.Module,
|
|
ir: Ir,
|
|
inst_map: std.AutoHashMapUnmanaged(Ir.Inst.Index, ValueInfo) = .empty,
|
|
errors: *std.ArrayListUnmanaged(Module.Error),
|
|
|
|
const InnerError = error{
|
|
OutOfMemory,
|
|
AnalysisFail,
|
|
TooManyConstants,
|
|
InvalidJump,
|
|
} || anyerror;
|
|
|
|
pub const ValueInfo = union(enum) {
|
|
none,
|
|
stack,
|
|
value: InternPool.Index,
|
|
variable: InternPool.Index,
|
|
knot: InternPool.Index,
|
|
stitch: InternPool.Index,
|
|
function: InternPool.Index,
|
|
temp: u32,
|
|
};
|
|
|
|
pub const Value = struct {
|
|
ip_index: InternPool.Index,
|
|
|
|
pub const Unwrapped = union(enum) {
|
|
bool: bool,
|
|
int: i64,
|
|
float: f64,
|
|
|
|
pub fn toFloat(v: Unwrapped) f64 {
|
|
return switch (v) {
|
|
.bool => |boolean| @floatFromInt(@intFromBool(boolean)),
|
|
.int => |int| @floatFromInt(int),
|
|
.float => |float| float,
|
|
};
|
|
}
|
|
|
|
pub fn isTruthy(v: Unwrapped) bool {
|
|
return switch (v) {
|
|
//.null => false,
|
|
.bool => |boolean| boolean,
|
|
.int => |int| int != 0,
|
|
.float => |float| float != 0.0,
|
|
//.str => true,
|
|
};
|
|
}
|
|
|
|
pub fn coerce(value: Unwrapped) Unwrapped {
|
|
return switch (value) {
|
|
.int => value,
|
|
.float => value,
|
|
.bool => |boolean| .{ .int = if (boolean) 1 else 0 },
|
|
//else => null,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub fn unwrap(value: Value, ip: *InternPool) Unwrapped {
|
|
switch (ip.values.items[@intFromEnum(value.toInterned())]) {
|
|
.bool => |boolean| return .{ .bool = boolean },
|
|
.int => |int| return .{ .int = int },
|
|
.float => |float| return .{ .float = @bitCast(float) },
|
|
.str => @panic("String unwrapping not implemented!"),
|
|
}
|
|
}
|
|
|
|
pub fn fromInterned(index: InternPool.Index) Value {
|
|
assert(index != .none);
|
|
return .{ .ip_index = index };
|
|
}
|
|
|
|
pub fn toInterned(value: Value) InternPool.Index {
|
|
assert(value.ip_index != .none);
|
|
return value.ip_index;
|
|
}
|
|
};
|
|
|
|
pub const SrcLoc = struct {
|
|
src_offset: u32,
|
|
};
|
|
|
|
fn fail(
|
|
sema: *Sema,
|
|
src: SrcLoc,
|
|
comptime format: []const u8,
|
|
args: anytype,
|
|
) error{ OutOfMemory, AnalysisFail } {
|
|
// TODO: Revisit this
|
|
const source_bytes = sema.module.tree.source;
|
|
const message = try std.fmt.allocPrint(sema.arena, format, args);
|
|
const loc = compile.findLineColumn(source_bytes, src.src_offset);
|
|
try sema.errors.append(sema.gpa, .{
|
|
.line = loc.line,
|
|
.column = loc.column,
|
|
.snippet = loc.source_line,
|
|
.message = message,
|
|
});
|
|
return error.AnalysisFail;
|
|
}
|
|
|
|
fn resolveInst(sema: *Sema, ref: Ir.Inst.Ref) ValueInfo {
|
|
if (ref.toIndex()) |index| {
|
|
return sema.inst_map.get(index).?;
|
|
}
|
|
return .{ .value = @enumFromInt(@intFromEnum(ref)) };
|
|
}
|
|
|
|
fn resolveValue(_: *Sema, info: ValueInfo) ?Value {
|
|
switch (info) {
|
|
.value => |value| return .fromInterned(value),
|
|
else => return null,
|
|
}
|
|
}
|
|
|
|
pub fn lookupIdentifier(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
ident: InternPool.Index,
|
|
src: SrcLoc,
|
|
) !Module.Namespace.Decl {
|
|
return sema.lookupInNamespace(builder.namespace, ident, src);
|
|
}
|
|
|
|
pub fn lookupInNamespace(
|
|
sema: *Sema,
|
|
namespace: *Module.Namespace,
|
|
ident: InternPool.Index,
|
|
src: SrcLoc,
|
|
) !Module.Namespace.Decl {
|
|
var scope: ?*Module.Namespace = namespace;
|
|
while (scope) |s| : (scope = s.parent) {
|
|
if (s.decls.get(ident)) |decl| return decl;
|
|
}
|
|
return sema.fail(src, "unknown identifier", .{});
|
|
}
|
|
|
|
pub fn deinit(sema: *Sema) void {
|
|
sema.inst_map.deinit(sema.gpa);
|
|
sema.* = undefined;
|
|
}
|
|
|
|
pub const Builder = struct {
|
|
sema: *Sema,
|
|
namespace: *Module.Namespace,
|
|
code: *Module.CodeChunk,
|
|
constants_map: std.AutoHashMapUnmanaged(InternPool.Index, u8) = .empty,
|
|
labels: std.ArrayListUnmanaged(Label) = .empty,
|
|
fixups: std.ArrayListUnmanaged(Fixup) = .empty,
|
|
|
|
const Label = struct {
|
|
code_offset: usize,
|
|
};
|
|
|
|
const Fixup = struct {
|
|
mode: enum {
|
|
relative,
|
|
absolute,
|
|
},
|
|
label_index: u32,
|
|
code_offset: u32,
|
|
};
|
|
|
|
const dummy_address = 0xffffffff;
|
|
|
|
pub fn deinit(builder: *Builder, gpa: std.mem.Allocator) void {
|
|
builder.constants_map.deinit(gpa);
|
|
builder.labels.deinit(gpa);
|
|
builder.fixups.deinit(gpa);
|
|
}
|
|
|
|
/// Reserve a stack slot for temporary variables.
|
|
fn addStackSlot(builder: *Builder) u8 {
|
|
const new_slot = builder.code.stack_size;
|
|
builder.code.stack_size += 1;
|
|
return @intCast(new_slot);
|
|
}
|
|
|
|
/// Reserve a stack slot for a parameter.
|
|
fn addParameter(builder: *Builder) u8 {
|
|
builder.code.args_count += 1;
|
|
return builder.addStackSlot();
|
|
}
|
|
|
|
fn addByteOp(builder: *Builder, op: Story.Opcode) error{OutOfMemory}!void {
|
|
const gpa = builder.sema.gpa;
|
|
const bytecode = &builder.code.bytecode;
|
|
//const byte_index = bytecode.items.len;
|
|
try bytecode.append(gpa, @intFromEnum(op));
|
|
//return .toIndex();
|
|
}
|
|
|
|
fn addConstOp(builder: *Builder, op: Story.Opcode, arg: u8) error{OutOfMemory}!void {
|
|
const gpa = builder.sema.gpa;
|
|
const bytecode = &builder.code.bytecode;
|
|
//const byte_index = bytecode.items.len;
|
|
try bytecode.ensureUnusedCapacity(gpa, 2);
|
|
bytecode.appendAssumeCapacity(@intFromEnum(op));
|
|
bytecode.appendAssumeCapacity(arg);
|
|
//return .{ .index = @intCast(byte_index) };
|
|
}
|
|
|
|
fn addJumpOp(builder: *Builder, op: Story.Opcode) error{OutOfMemory}!u32 {
|
|
const gpa = builder.sema.gpa;
|
|
const bytecode = &builder.code.bytecode;
|
|
try bytecode.ensureUnusedCapacity(gpa, 3);
|
|
bytecode.appendAssumeCapacity(@intFromEnum(op));
|
|
bytecode.appendAssumeCapacity(0xff);
|
|
bytecode.appendAssumeCapacity(0xff);
|
|
return @intCast(bytecode.items.len - 2);
|
|
}
|
|
|
|
fn addFixup(builder: *Builder, op: Story.Opcode, label: usize) !void {
|
|
return builder.fixups.append(builder.sema.gpa, .{
|
|
.mode = .relative,
|
|
.label_index = @intCast(label),
|
|
.code_offset = try builder.addJumpOp(op),
|
|
});
|
|
}
|
|
|
|
fn addFixupAbsolute(builder: *Builder, op: Story.Opcode, label: usize) !void {
|
|
return builder.fixups.append(builder.sema.gpa, .{
|
|
.mode = .absolute,
|
|
.label_index = @intCast(label),
|
|
.code_offset = try builder.addJumpOp(op),
|
|
});
|
|
}
|
|
|
|
fn addLabel(builder: *Builder) error{OutOfMemory}!usize {
|
|
const label_index = builder.labels.items.len;
|
|
try builder.labels.append(builder.sema.gpa, .{
|
|
.code_offset = dummy_address,
|
|
});
|
|
return label_index;
|
|
}
|
|
|
|
fn setLabel(builder: *Builder, label_index: usize) void {
|
|
const bytecode = &builder.code.bytecode;
|
|
const code_offset = bytecode.items.len;
|
|
assert(label_index <= builder.labels.items.len);
|
|
|
|
const label_data = &builder.labels.items[label_index];
|
|
label_data.code_offset = code_offset;
|
|
}
|
|
|
|
fn getOrPutConstantIndex(builder: *Builder, index: InternPool.Index) !u8 {
|
|
const gpa = builder.sema.gpa;
|
|
const constants = &builder.code.constants;
|
|
if (builder.constants_map.get(index)) |local_index| return local_index;
|
|
|
|
const local_index: u8 = @intCast(constants.items.len);
|
|
try constants.append(gpa, @intCast(@intFromEnum(index)));
|
|
try builder.constants_map.put(gpa, index, local_index);
|
|
return local_index;
|
|
}
|
|
|
|
pub fn finalize(builder: *Builder) !void {
|
|
const bytecode = &builder.code.bytecode;
|
|
|
|
for (builder.fixups.items) |fixup| {
|
|
const label = builder.labels.items[fixup.label_index];
|
|
assert(label.code_offset != dummy_address);
|
|
const target_offset: usize = switch (fixup.mode) {
|
|
.relative => label.code_offset - fixup.code_offset - 2,
|
|
.absolute => label.code_offset,
|
|
};
|
|
if (target_offset >= std.math.maxInt(u16)) {
|
|
std.debug.print("Too much code to jump over!\n", .{});
|
|
return error.InvalidJump;
|
|
}
|
|
assert(bytecode.capacity >= label.code_offset + 2);
|
|
bytecode.items[fixup.code_offset] = @intCast((target_offset >> 8) & 0xff);
|
|
bytecode.items[fixup.code_offset + 1] = @intCast(target_offset & 0xff);
|
|
}
|
|
}
|
|
|
|
fn ensureLoad(self: *Builder, info: ValueInfo) InnerError!void {
|
|
switch (info) {
|
|
.none => unreachable, // caller should never load .none
|
|
.stack => {},
|
|
.value => |index| {
|
|
const local_index = try self.getOrPutConstantIndex(index);
|
|
try self.addConstOp(.load_const, @intCast(local_index));
|
|
},
|
|
.variable,
|
|
.knot,
|
|
.stitch,
|
|
.function,
|
|
=> |index| {
|
|
const local_index = try self.getOrPutConstantIndex(index);
|
|
try self.addConstOp(.load_global, @intCast(local_index));
|
|
},
|
|
.temp => |temp| try self.addConstOp(.load, @intCast(temp)),
|
|
}
|
|
}
|
|
};
|
|
|
|
fn foldArith(
|
|
lhs: Value.Unwrapped,
|
|
rhs: Value.Unwrapped,
|
|
op: Story.Opcode,
|
|
) !Value.Unwrapped {
|
|
const l = lhs.coerce();
|
|
const r = rhs.coerce();
|
|
if (l == .int and r == .int) {
|
|
return switch (op) {
|
|
.add => .{ .int = l.int +% r.int },
|
|
.sub => .{ .int = l.int -% r.int },
|
|
.mul => .{ .int = l.int *% r.int },
|
|
.div => if (r.int == 0)
|
|
error.DivisionByZero
|
|
else
|
|
.{ .int = @divTrunc(l.int, r.int) },
|
|
.mod => if (r.int == 0)
|
|
error.DivisionByZero
|
|
else
|
|
.{ .int = @mod(l.int, r.int) },
|
|
else => unreachable,
|
|
};
|
|
}
|
|
|
|
const lf = l.toFloat();
|
|
const rf = r.toFloat();
|
|
return switch (op) {
|
|
.add => .{ .float = lf + rf },
|
|
.sub => .{ .float = lf - rf },
|
|
.mul => .{ .float = lf * rf },
|
|
.div => if (rf == 0.0)
|
|
error.DivisionByZero
|
|
else
|
|
.{ .float = lf / rf },
|
|
.mod => if (rf == 0.0)
|
|
error.DivisionByZero
|
|
else
|
|
.{ .float = @mod(lf, rf) },
|
|
else => unreachable,
|
|
};
|
|
}
|
|
|
|
fn foldCmp(
|
|
lhs: Value.Unwrapped,
|
|
rhs: Value.Unwrapped,
|
|
op: Story.Opcode,
|
|
) !Value.Unwrapped {
|
|
switch (op) {
|
|
.cmp_eq => return .{ .bool = std.meta.eql(lhs, rhs) },
|
|
.cmp_neq => return .{ .bool = !std.meta.eql(lhs, rhs) },
|
|
else => {},
|
|
}
|
|
|
|
const lf = lhs.coerce().toFloat();
|
|
const rf = rhs.coerce().toFloat();
|
|
const result = switch (op) {
|
|
.cmp_lt => lf < rf,
|
|
.cmp_gt => lf > rf,
|
|
.cmp_lte => lf <= rf,
|
|
.cmp_gte => lf >= rf,
|
|
else => unreachable,
|
|
};
|
|
return .{ .bool = result };
|
|
}
|
|
|
|
fn foldConstant(
|
|
lhs: Value.Unwrapped,
|
|
rhs: Value.Unwrapped,
|
|
op: Story.Opcode,
|
|
) !Value.Unwrapped {
|
|
switch (op) {
|
|
.add,
|
|
.sub,
|
|
.mul,
|
|
.div,
|
|
.mod,
|
|
=> return foldArith(lhs, rhs, op),
|
|
.cmp_eq,
|
|
.cmp_neq,
|
|
.cmp_lt,
|
|
.cmp_gt,
|
|
.cmp_lte,
|
|
.cmp_gte,
|
|
=> return foldCmp(lhs, rhs, op),
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
fn irInt(sema: *Sema, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const value = sema.ir.instructions[@intFromEnum(inst)].data.int;
|
|
const ip_index = try sema.module.intern_pool.getOrPutInt(sema.gpa, value);
|
|
return .{ .value = ip_index };
|
|
}
|
|
|
|
fn irFloat(sema: *Sema, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const value = sema.ir.instructions[@intFromEnum(inst)].data.float;
|
|
const ip_index = try sema.module.intern_pool.getOrPutFloat(sema.gpa, value);
|
|
return .{ .value = ip_index };
|
|
}
|
|
|
|
fn irStr(sema: *Sema, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.str;
|
|
const ip_index = try sema.module.intern_pool.getOrPutStr(sema.gpa, data.start);
|
|
return .{ .value = ip_index };
|
|
}
|
|
|
|
fn irUnaryOp(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
op: Story.Opcode,
|
|
) InnerError!ValueInfo {
|
|
const gpa = sema.gpa;
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.un;
|
|
const ip = &sema.module.intern_pool;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
//const lhs_src: SrcLoc = .{ .src_offset = 0 };
|
|
//try sema.analyzeArithmeticArg(builder, lhs, lhs_src);
|
|
|
|
if (sema.resolveValue(lhs)) |lhs_info| {
|
|
switch (lhs_info.unwrap(ip)) {
|
|
.bool => |boolean| {
|
|
const new_value = switch (op) {
|
|
.not => !boolean,
|
|
.neg => return error.TypeError,
|
|
else => unreachable,
|
|
};
|
|
return .{ .value = ip.getOrPutBool(new_value) };
|
|
},
|
|
.int => |int| {
|
|
const new_value: i64 = switch (op) {
|
|
.not => if (int > 0) 0 else 1,
|
|
.neg => -int,
|
|
else => unreachable,
|
|
};
|
|
return .{ .value = try ip.getOrPutInt(gpa, new_value) };
|
|
},
|
|
.float => |float| {
|
|
const new_value: f64 = switch (op) {
|
|
.not => if (float > 0.0) 0.0 else 1.0,
|
|
.neg => -float,
|
|
else => unreachable,
|
|
};
|
|
return .{ .value = try ip.getOrPutFloat(gpa, new_value) };
|
|
},
|
|
}
|
|
}
|
|
|
|
try builder.ensureLoad(lhs);
|
|
try builder.addByteOp(op);
|
|
return .stack;
|
|
}
|
|
|
|
fn irBinaryOp(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
op: Story.Opcode,
|
|
) InnerError!ValueInfo {
|
|
const gpa = sema.gpa;
|
|
const ip = &sema.module.intern_pool;
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.bin;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
const rhs = sema.resolveInst(data.rhs);
|
|
//const lhs_src: SrcLoc = .{ .src_offset = 0 };
|
|
//const rhs_src: SrcLoc = .{ .src_offset = 0 };
|
|
//try sema.analyzeArithmeticArg(builder, lhs, lhs_src);
|
|
//try sema.analyzeArithmeticArg(builder, rhs, rhs_src);
|
|
|
|
if (sema.resolveValue(lhs)) |lhs_value| {
|
|
if (sema.resolveValue(rhs)) |rhs_value| {
|
|
const lhs_coerced = lhs_value.unwrap(ip).coerce();
|
|
const rhs_coerced = rhs_value.unwrap(ip).coerce();
|
|
return switch (try foldConstant(lhs_coerced, rhs_coerced, op)) {
|
|
.bool => |boolean| .{ .value = ip.getOrPutBool(boolean) },
|
|
.int => |int| .{ .value = try ip.getOrPutInt(gpa, int) },
|
|
.float => |float| .{ .value = try ip.getOrPutFloat(gpa, float) },
|
|
};
|
|
}
|
|
}
|
|
|
|
try builder.ensureLoad(lhs);
|
|
try builder.ensureLoad(rhs);
|
|
try builder.addByteOp(op);
|
|
return .stack;
|
|
}
|
|
|
|
fn irLogicalOp(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
logical_or: bool,
|
|
) InnerError!ValueInfo {
|
|
const ip = &sema.module.intern_pool;
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.bin;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
const rhs = sema.resolveInst(data.rhs);
|
|
|
|
if (sema.resolveValue(lhs)) |lhs_info| {
|
|
const lhs_value = lhs_info.unwrap(ip);
|
|
if (sema.resolveValue(rhs)) |_| {
|
|
return if (logical_or)
|
|
if (lhs_value.isTruthy()) lhs else rhs
|
|
else if (!lhs_value.isTruthy()) lhs else rhs;
|
|
}
|
|
|
|
if (logical_or and lhs_value.isTruthy()) return lhs;
|
|
if (!logical_or and !lhs_value.isTruthy()) return lhs;
|
|
try builder.ensureLoad(rhs);
|
|
return .none;
|
|
}
|
|
|
|
const else_label = try builder.addLabel();
|
|
try builder.ensureLoad(lhs);
|
|
try builder.addFixup(if (logical_or) .jmp_t else .jmp_f, else_label);
|
|
try builder.addByteOp(.pop);
|
|
try builder.ensureLoad(rhs);
|
|
builder.setLabel(else_label);
|
|
return .none;
|
|
}
|
|
|
|
fn irDeclRef(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
inline_block: bool,
|
|
) InnerError!ValueInfo {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.str_tok;
|
|
const ip_index = try sema.module.intern_pool.getOrPutStr(sema.gpa, data.start);
|
|
const src_loc: SrcLoc = .{ .src_offset = data.src_offset };
|
|
const ident = try sema.lookupIdentifier(builder, ip_index, src_loc);
|
|
if (inline_block) {
|
|
switch (ident.tag) {
|
|
.knot, .stitch, .function => unreachable,
|
|
.var_const => return sema.resolveGlobalDecl(builder, ip_index, src_loc),
|
|
.var_mut => return sema.fail(
|
|
src_loc,
|
|
"global variable assignments cannot refer to other variables",
|
|
.{},
|
|
),
|
|
}
|
|
} else {
|
|
switch (ident.tag) {
|
|
.knot => return .{ .knot = ip_index },
|
|
.stitch => return .{ .stitch = ip_index },
|
|
.function => return .{ .function = ip_index },
|
|
.var_mut => return .{ .variable = ip_index },
|
|
.var_const => return .{ .variable = ip_index },
|
|
}
|
|
}
|
|
}
|
|
|
|
fn irAlloc(_: *Sema, builder: *Builder, _: Ir.Inst.Index) InnerError!ValueInfo {
|
|
// TODO: Add constraints on how many temporaries we can have.
|
|
// max(u8) or max(u16) are most likey appropriate.
|
|
builder.code.locals_count += 1;
|
|
return .{ .temp = builder.addStackSlot() };
|
|
}
|
|
|
|
fn irStore(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.bin;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
const rhs = sema.resolveInst(data.rhs);
|
|
const src: SrcLoc = .{ .src_offset = 0 };
|
|
|
|
try builder.ensureLoad(rhs);
|
|
|
|
switch (lhs) {
|
|
.none => unreachable,
|
|
.stack => {},
|
|
.value => |_| return sema.fail(src, "could not assign to constant value", .{}),
|
|
.variable => |index| {
|
|
const local_index = try builder.getOrPutConstantIndex(index);
|
|
try builder.addConstOp(.store_global, @intCast(local_index));
|
|
},
|
|
.temp => |temp| try builder.addConstOp(.store, @intCast(temp)),
|
|
.knot => |_| return sema.fail(src, "could not assign to knot", .{}),
|
|
.stitch => |_| return sema.fail(src, "could not assign to stitch", .{}),
|
|
.function => |_| return sema.fail(src, "could not assign to function", .{}),
|
|
}
|
|
|
|
try builder.addByteOp(.pop);
|
|
}
|
|
|
|
fn irLoad(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.un;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
if (lhs == .value) return lhs;
|
|
|
|
try builder.ensureLoad(lhs);
|
|
return .stack;
|
|
}
|
|
|
|
fn irCondBr(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.CondBr, data.extra_index);
|
|
const then_body = sema.ir.bodySlice(extra.end, extra.data.then_body_len);
|
|
const else_body = sema.ir.bodySlice(extra.end + then_body.len, extra.data.else_body_len);
|
|
const else_label = try builder.addLabel();
|
|
const end_label = try builder.addLabel();
|
|
const condition = sema.resolveInst(extra.data.condition);
|
|
if (condition != .none) try builder.ensureLoad(condition);
|
|
|
|
try builder.addFixup(.jmp_f, else_label);
|
|
try builder.addByteOp(.pop);
|
|
_ = try analyzeBodyInner(sema, builder, then_body, false);
|
|
|
|
try builder.addFixup(.jmp, end_label);
|
|
builder.setLabel(else_label);
|
|
try builder.addByteOp(.pop);
|
|
|
|
_ = try analyzeBodyInner(sema, builder, else_body, false);
|
|
builder.setLabel(end_label);
|
|
return .none;
|
|
}
|
|
|
|
fn irBreak(sema: *Sema, inst: Ir.Inst.Index) InnerError!void {
|
|
_ = sema;
|
|
_ = inst;
|
|
}
|
|
|
|
fn irBreakInline(sema: *Sema, inst: Ir.Inst.Index) InnerError!ValueInfo {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.bin;
|
|
const rvalue_inst = sema.resolveInst(data.rhs);
|
|
return rvalue_inst;
|
|
}
|
|
|
|
fn irBlock(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Block, data.extra_index);
|
|
const body = sema.ir.bodySlice(extra.end, extra.data.body_len);
|
|
_ = try analyzeBodyInner(sema, builder, body, false);
|
|
}
|
|
|
|
fn irSwitchBr(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const gpa = sema.gpa;
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.SwitchBr, data.extra_index);
|
|
const cases_slice = sema.ir.bodySlice(extra.end, extra.data.cases_len);
|
|
|
|
var case_labels: std.ArrayListUnmanaged(usize) = .empty;
|
|
try case_labels.ensureUnusedCapacity(gpa, cases_slice.len + 1);
|
|
defer case_labels.deinit(gpa);
|
|
|
|
const condition = sema.resolveInst(extra.data.operand);
|
|
if (condition != .none) try builder.ensureLoad(condition);
|
|
|
|
const exit_label = try builder.addLabel();
|
|
const cmp_var = builder.addStackSlot();
|
|
try builder.addConstOp(.store, cmp_var);
|
|
|
|
for (cases_slice) |case_index| {
|
|
const case_extra = sema.ir.extraData(Ir.Inst.SwitchBr.Case, @intFromEnum(case_index));
|
|
const case_expr = sema.resolveInst(case_extra.data.operand);
|
|
const case_label_index = try builder.addLabel();
|
|
case_labels.appendAssumeCapacity(case_label_index);
|
|
|
|
try builder.addConstOp(.load, @intCast(cmp_var));
|
|
try builder.ensureLoad(case_expr);
|
|
try builder.addByteOp(.cmp_eq);
|
|
try builder.addFixup(.jmp_t, case_label_index);
|
|
try builder.addByteOp(.pop);
|
|
}
|
|
|
|
const else_label = try builder.addLabel();
|
|
try builder.addFixup(.jmp, else_label);
|
|
|
|
for (cases_slice, case_labels.items) |case_index, label_index| {
|
|
const case_extra = sema.ir.extraData(Ir.Inst.SwitchBr.Case, @intFromEnum(case_index));
|
|
const case_body = sema.ir.bodySlice(case_extra.end, case_extra.data.body_len);
|
|
|
|
builder.setLabel(label_index);
|
|
try builder.addByteOp(.pop);
|
|
_ = try analyzeBodyInner(sema, builder, case_body, false);
|
|
try builder.addFixup(.jmp, exit_label);
|
|
}
|
|
|
|
const else_body = sema.ir.bodySlice(
|
|
extra.end + extra.data.cases_len,
|
|
extra.data.else_body_len,
|
|
);
|
|
|
|
builder.setLabel(else_label);
|
|
_ = try analyzeBodyInner(sema, builder, else_body, false);
|
|
builder.setLabel(exit_label);
|
|
}
|
|
|
|
fn irContentPush(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.un;
|
|
const lhs = sema.resolveInst(data.lhs);
|
|
if (lhs == .none) return error.AnalysisFail;
|
|
if (lhs != .stack) try builder.ensureLoad(lhs);
|
|
try builder.addByteOp(.stream_push);
|
|
}
|
|
|
|
fn irChoiceBr(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const gpa = sema.gpa;
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const choice_extra = sema.ir.extraData(Ir.Inst.ChoiceBr, data.extra_index);
|
|
const options_slice = sema.ir.bodySlice(choice_extra.end, choice_extra.data.cases_len);
|
|
|
|
var branch_labels: std.ArrayListUnmanaged(usize) = .empty;
|
|
try branch_labels.ensureUnusedCapacity(gpa, options_slice.len + 1);
|
|
defer branch_labels.deinit(gpa);
|
|
|
|
for (options_slice) |option_index| {
|
|
const case_extra = sema.ir.extraData(Ir.Inst.ChoiceBr.Case, @intFromEnum(option_index));
|
|
const lhs_slice = sema.ir.bodySlice(
|
|
case_extra.end,
|
|
case_extra.data.lhs_len,
|
|
);
|
|
const mhs_slice = sema.ir.bodySlice(
|
|
case_extra.end + case_extra.data.lhs_len,
|
|
case_extra.data.mhs_len,
|
|
);
|
|
|
|
const case_label = try builder.addLabel();
|
|
branch_labels.appendAssumeCapacity(case_label);
|
|
|
|
try builder.addByteOp(.stream_mark);
|
|
_ = try analyzeBodyInner(sema, builder, lhs_slice, false);
|
|
_ = try analyzeBodyInner(sema, builder, mhs_slice, false);
|
|
try builder.addFixupAbsolute(.br_push, case_label);
|
|
}
|
|
|
|
try builder.addByteOp(.br_table);
|
|
try builder.addByteOp(.br_select_index);
|
|
try builder.addByteOp(.br_dispatch);
|
|
|
|
for (options_slice, branch_labels.items) |option_index, label| {
|
|
const case_extra = sema.ir.extraData(Ir.Inst.ChoiceBr.Case, @intFromEnum(option_index));
|
|
const lhs_slice = sema.ir.bodySlice(
|
|
case_extra.end,
|
|
case_extra.data.lhs_len,
|
|
);
|
|
const rhs_slice = sema.ir.bodySlice(
|
|
case_extra.end +
|
|
case_extra.data.lhs_len +
|
|
case_extra.data.mhs_len,
|
|
case_extra.data.rhs_len,
|
|
);
|
|
const body_slice = sema.ir.bodySlice(
|
|
case_extra.end +
|
|
case_extra.data.lhs_len +
|
|
case_extra.data.mhs_len +
|
|
case_extra.data.rhs_len,
|
|
case_extra.data.body_len,
|
|
);
|
|
|
|
builder.setLabel(label);
|
|
|
|
_ = try analyzeBodyInner(sema, builder, lhs_slice, false);
|
|
_ = try analyzeBodyInner(sema, builder, rhs_slice, false);
|
|
try builder.addByteOp(.stream_line);
|
|
_ = try analyzeBodyInner(sema, builder, body_slice, false);
|
|
}
|
|
}
|
|
|
|
fn irRet(sema: *Sema, builder: *Builder, inst: Ir.Inst.Index) InnerError!void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.un;
|
|
if (data.lhs.toIndexAllowNone()) |index| {
|
|
const value = sema.inst_map.get(index).?;
|
|
if (value != .none) try builder.ensureLoad(value);
|
|
}
|
|
try builder.addByteOp(.ret);
|
|
}
|
|
|
|
fn irImplicitRet(_: *Sema, builder: *Builder, _: Ir.Inst.Index) InnerError!void {
|
|
try builder.addByteOp(.exit);
|
|
}
|
|
|
|
fn irCall(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
comptime kind: enum { direct, field },
|
|
) !ValueInfo {
|
|
const ExtraType = switch (kind) {
|
|
.direct => Ir.Inst.Call,
|
|
.field => Ir.Inst.FieldCall,
|
|
};
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(ExtraType, data.extra_index);
|
|
const body = sema.ir.extra[extra.end..];
|
|
const callee_src: SrcLoc = .{ .src_offset = data.src_offset };
|
|
switch (kind) {
|
|
.direct => {
|
|
const callee = sema.resolveInst(extra.data.callee);
|
|
_ = try analyzeCallTarget(sema, builder, callee_src, callee);
|
|
},
|
|
.field => {
|
|
const callee = sema.resolveInst(extra.data.obj_ptr);
|
|
const target = try analyzeCallTarget(sema, builder, callee_src, callee);
|
|
const ip_index = try sema.module.intern_pool.getOrPutStr(
|
|
sema.gpa,
|
|
extra.data.field_name_start,
|
|
);
|
|
const e = try sema.lookupInNamespace(target.namespace.?, ip_index, callee_src);
|
|
switch (e.tag) {
|
|
.function => {
|
|
const local_index = try builder.getOrPutConstantIndex(ip_index);
|
|
_ = try builder.addConstOp(.load_attr, @intCast(local_index));
|
|
},
|
|
else => return sema.fail(callee_src, "invalid call target", .{}),
|
|
}
|
|
},
|
|
}
|
|
|
|
const args_len = extra.data.args_len;
|
|
var arg_start: u32 = args_len;
|
|
var i: u32 = 0;
|
|
while (i < args_len) : (i += 1) {
|
|
const arg_end = sema.ir.extra[extra.end + i];
|
|
defer arg_start = arg_end;
|
|
const arg_body = body[arg_start..arg_end];
|
|
const arg_value = try analyzeBodyInner(sema, builder, @ptrCast(arg_body), false);
|
|
if (arg_value != .none) try builder.ensureLoad(arg_value);
|
|
}
|
|
try builder.addConstOp(.call, @intCast(args_len));
|
|
return .stack;
|
|
}
|
|
|
|
fn irDivert(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
comptime kind: enum { direct, field },
|
|
) !void {
|
|
const ExtraType = switch (kind) {
|
|
.direct => Ir.Inst.Call,
|
|
.field => Ir.Inst.FieldCall,
|
|
};
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(ExtraType, data.extra_index);
|
|
const body = sema.ir.extra[extra.end..];
|
|
const callee_src: SrcLoc = .{ .src_offset = data.src_offset };
|
|
switch (kind) {
|
|
.direct => {
|
|
const callee = sema.resolveInst(extra.data.callee);
|
|
_ = try analyzeDivertTarget(sema, builder, callee_src, callee);
|
|
},
|
|
.field => {
|
|
const callee = sema.resolveInst(extra.data.obj_ptr);
|
|
const target = try analyzeDivertTarget(sema, builder, callee_src, callee);
|
|
const ip_index = try sema.module.intern_pool.getOrPutStr(
|
|
sema.gpa,
|
|
extra.data.field_name_start,
|
|
);
|
|
const e = try sema.lookupInNamespace(target.namespace.?, ip_index, callee_src);
|
|
switch (e.tag) {
|
|
.knot => {
|
|
const local_index = try builder.getOrPutConstantIndex(ip_index);
|
|
_ = try builder.addConstOp(.load_attr, @intCast(local_index));
|
|
},
|
|
else => return sema.fail(callee_src, "invalid divert target", .{}),
|
|
}
|
|
},
|
|
}
|
|
|
|
const args_len = extra.data.args_len;
|
|
var arg_start: u32 = args_len;
|
|
var i: u32 = 0;
|
|
while (i < args_len) : (i += 1) {
|
|
const arg_end = sema.ir.extra[extra.end + i];
|
|
defer arg_start = arg_end;
|
|
const arg_body = body[arg_start..arg_end];
|
|
const arg_value = try analyzeBodyInner(sema, builder, @ptrCast(arg_body), false);
|
|
if (arg_value != .none) try builder.ensureLoad(arg_value);
|
|
}
|
|
try builder.addConstOp(.divert, @intCast(args_len));
|
|
}
|
|
|
|
fn irFieldPtr(_: *Sema, _: *Builder, _: Ir.Inst.Index) !ValueInfo {
|
|
return .none;
|
|
}
|
|
|
|
// TODO: Check for duplicate parameters.
|
|
fn irParam(_: *Sema, builder: *Builder, _: Ir.Inst.Index) !ValueInfo {
|
|
// TODO: Add constraints on how many temporaries we can have.
|
|
// max(u8) or max(u16) are most likey appropriate.
|
|
return .{ .temp = builder.addParameter() };
|
|
}
|
|
|
|
fn irDone(_: *Sema, builder: *Builder, _: Ir.Inst.Index) !ValueInfo {
|
|
try builder.addByteOp(.done);
|
|
return .none;
|
|
}
|
|
|
|
fn irExit(_: *Sema, builder: *Builder, _: Ir.Inst.Index) !ValueInfo {
|
|
try builder.addByteOp(.exit);
|
|
return .none;
|
|
}
|
|
|
|
fn analyzeArithmeticArg(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
arg: ValueInfo,
|
|
arg_src: SrcLoc,
|
|
) !void {
|
|
switch (arg) {
|
|
.value => |index| {
|
|
const local_index = try builder.getOrPutConstantIndex(index);
|
|
try builder.addConstOp(.load_const, @intCast(local_index));
|
|
},
|
|
//.temporary => |index| {
|
|
// try builder.addConstOp(.load, @intCast(index));
|
|
//},
|
|
//.variable => |index| {
|
|
// const local_index = try builder.getOrPutConstantIndex(index);
|
|
// try builder.addConstOp(.load_global, @intCast(local_index));
|
|
//},
|
|
.knot => return fail(sema, arg_src, "invalid operand to arithmetic expression", .{}),
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
fn analyzeCallTarget(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
src: SrcLoc,
|
|
callee: ValueInfo,
|
|
) !Module.Namespace.Decl {
|
|
switch (callee) {
|
|
.function => |ip_index| {
|
|
try builder.ensureLoad(callee);
|
|
return sema.lookupIdentifier(builder, ip_index, src);
|
|
},
|
|
else => return sema.fail(src, "invalid call target", .{}),
|
|
}
|
|
}
|
|
|
|
fn analyzeDivertTarget(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
src: SrcLoc,
|
|
callee: ValueInfo,
|
|
) !Module.Namespace.Decl {
|
|
switch (callee) {
|
|
.knot => |ip_index| {
|
|
try builder.ensureLoad(callee);
|
|
return sema.lookupIdentifier(builder, ip_index, src);
|
|
},
|
|
else => return sema.fail(src, "invalid divert target", .{}),
|
|
}
|
|
}
|
|
|
|
fn analyzeBodyInner(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
body: []const Ir.Inst.Index,
|
|
inline_block: bool,
|
|
) InnerError!ValueInfo {
|
|
var result: ValueInfo = .none;
|
|
for (body) |inst| {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)];
|
|
result = switch (data.tag) {
|
|
.file => unreachable, // never present inside block bodies
|
|
.declaration => unreachable, // never present inside block bodies
|
|
.decl_var => unreachable, // never present inside block bodies
|
|
.decl_knot => unreachable, // never present inside block bodies
|
|
.decl_stitch => unreachable, // never present inside block bodies
|
|
.decl_function => unreachable, // never present inside block bodies
|
|
.alloc => try irAlloc(sema, builder, inst),
|
|
.store => {
|
|
try irStore(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.load => try irLoad(sema, builder, inst),
|
|
.int => try irInt(sema, inst),
|
|
.float => try irFloat(sema, inst),
|
|
.str => try irStr(sema, inst),
|
|
.add => try irBinaryOp(sema, builder, inst, .add),
|
|
.sub => try irBinaryOp(sema, builder, inst, .sub),
|
|
.mul => try irBinaryOp(sema, builder, inst, .mul),
|
|
.div => try irBinaryOp(sema, builder, inst, .div),
|
|
.mod => try irBinaryOp(sema, builder, inst, .mod),
|
|
.neg => try irUnaryOp(sema, builder, inst, .neg),
|
|
.not => try irUnaryOp(sema, builder, inst, .not),
|
|
.bool_and => try irLogicalOp(sema, builder, inst, false),
|
|
.bool_or => try irLogicalOp(sema, builder, inst, true),
|
|
.cmp_eq => try irBinaryOp(sema, builder, inst, .cmp_eq),
|
|
.cmp_neq => try irBinaryOp(sema, builder, inst, .cmp_neq),
|
|
.cmp_lt => try irBinaryOp(sema, builder, inst, .cmp_lt),
|
|
.cmp_lte => try irBinaryOp(sema, builder, inst, .cmp_lte),
|
|
.cmp_gt => try irBinaryOp(sema, builder, inst, .cmp_gt),
|
|
.cmp_gte => try irBinaryOp(sema, builder, inst, .cmp_gte),
|
|
.decl_ref => try irDeclRef(sema, builder, inst, inline_block),
|
|
.ret => {
|
|
try irRet(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.implicit_ret => {
|
|
try irImplicitRet(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.condbr => try irCondBr(sema, builder, inst),
|
|
.@"break" => {
|
|
try irBreak(sema, inst);
|
|
continue;
|
|
},
|
|
.break_inline => try irBreakInline(sema, inst),
|
|
.block => {
|
|
try irBlock(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.content_push => {
|
|
try irContentPush(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.content_line => {
|
|
try builder.addByteOp(.stream_line);
|
|
continue;
|
|
},
|
|
.content_glue => {
|
|
try builder.addByteOp(.stream_glue);
|
|
continue;
|
|
},
|
|
.choice_br => {
|
|
try irChoiceBr(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.switch_br => {
|
|
try irSwitchBr(sema, builder, inst);
|
|
continue;
|
|
},
|
|
.call => try irCall(sema, builder, inst, .direct),
|
|
.field_call => try irCall(sema, builder, inst, .field),
|
|
.divert => {
|
|
try irDivert(sema, builder, inst, .direct);
|
|
continue;
|
|
},
|
|
.field_divert => {
|
|
try irDivert(sema, builder, inst, .field);
|
|
continue;
|
|
},
|
|
.field_ptr => try irFieldPtr(sema, builder, inst),
|
|
.param => try irParam(sema, builder, inst),
|
|
.done => try irDone(sema, builder, inst),
|
|
.exit => try irExit(sema, builder, inst),
|
|
};
|
|
try sema.inst_map.put(sema.gpa, inst, result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// TODO: No return allowed.
|
|
pub fn analyzeStitch(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
) !void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Stitch, data.extra_index);
|
|
const body = sema.ir.bodySlice(extra.end, extra.data.body_len);
|
|
_ = try analyzeBodyInner(sema, builder, body, false);
|
|
}
|
|
|
|
// TODO: No diverts allowed.
|
|
pub fn analyzeFunction(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
) !void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Function, data.extra_index);
|
|
const body = sema.ir.bodySlice(extra.end, extra.data.body_len);
|
|
_ = try analyzeBodyInner(sema, builder, body, false);
|
|
}
|
|
|
|
// TODO: No return allowed.
|
|
pub fn analyzeKnot(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
inst: Ir.Inst.Index,
|
|
) !void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Knot, data.extra_index);
|
|
const body = sema.ir.bodySlice(extra.end, extra.data.body_len);
|
|
_ = try analyzeBodyInner(sema, builder, body, false);
|
|
}
|
|
|
|
fn analyzeNestedDecl(
|
|
sema: *Sema,
|
|
namespace: *Module.Namespace,
|
|
inst: Ir.Inst.Index,
|
|
) !void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Declaration, data.extra_index).data;
|
|
const decl = sema.ir.instructions[@intFromEnum(extra.value)];
|
|
const decl_name = try sema.module.intern_pool.getOrPutStr(sema.gpa, extra.name);
|
|
|
|
switch (decl.tag) {
|
|
.decl_stitch => {
|
|
const child_namespace = try sema.module.createNamespace(namespace);
|
|
try namespace.decls.put(sema.arena, decl_name, .{
|
|
.tag = .knot,
|
|
.decl_inst = extra.value,
|
|
.args_count = 0,
|
|
.namespace = child_namespace,
|
|
});
|
|
try sema.module.queueWorkItem(.{
|
|
.tag = .stitch,
|
|
.decl_name = decl_name,
|
|
.inst_index = extra.value,
|
|
.namespace = child_namespace,
|
|
});
|
|
},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
fn scanTopLevelDecl(
|
|
sema: *Sema,
|
|
namespace: *Module.Namespace,
|
|
inst: Ir.Inst.Index,
|
|
) !void {
|
|
const data = sema.ir.instructions[@intFromEnum(inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Declaration, data.extra_index).data;
|
|
const decl_inst = sema.ir.instructions[@intFromEnum(extra.value)];
|
|
const decl_name = try sema.module.intern_pool.getOrPutStr(sema.gpa, extra.name);
|
|
const src_loc: SrcLoc = .{ .src_offset = data.src_offset };
|
|
|
|
switch (decl_inst.tag) {
|
|
.decl_var => {
|
|
const gop = try namespace.decls.getOrPut(sema.arena, decl_name);
|
|
if (gop.found_existing) {
|
|
return sema.fail(src_loc, "duplicate identifier", .{});
|
|
} else {
|
|
gop.value_ptr.* = .{
|
|
.tag = if (extra.flags == 0x01) .var_const else .var_mut,
|
|
.namespace = null,
|
|
.decl_inst = extra.value,
|
|
.args_count = 0,
|
|
};
|
|
}
|
|
},
|
|
.decl_knot => {
|
|
const _data = sema.ir.instructions[@intFromEnum(extra.value)].data.payload;
|
|
const _extra = sema.ir.extraData(Ir.Inst.Knot, _data.extra_index);
|
|
const _body = sema.ir.bodySlice(_extra.end, _extra.data.body_len);
|
|
const _stitches = sema.ir.bodySlice(_extra.end + _body.len, _extra.data.stitches_len);
|
|
|
|
const child_namespace = try sema.module.createNamespace(namespace);
|
|
const gop = try namespace.decls.getOrPut(sema.arena, decl_name);
|
|
if (gop.found_existing) {
|
|
return sema.fail(src_loc, "duplicate identifier", .{});
|
|
} else {
|
|
gop.value_ptr.* = .{
|
|
.tag = .knot,
|
|
.decl_inst = extra.value,
|
|
.args_count = 0,
|
|
.namespace = child_namespace,
|
|
};
|
|
}
|
|
|
|
try sema.module.queueWorkItem(.{
|
|
.tag = .knot,
|
|
.decl_name = decl_name,
|
|
.inst_index = extra.value,
|
|
.namespace = child_namespace,
|
|
});
|
|
|
|
for (_stitches) |st| {
|
|
try analyzeNestedDecl(sema, child_namespace, st);
|
|
}
|
|
},
|
|
.decl_stitch => {
|
|
const child_namespace = try sema.module.createNamespace(namespace);
|
|
const gop = try namespace.decls.getOrPut(sema.arena, decl_name);
|
|
if (gop.found_existing) {
|
|
return sema.fail(src_loc, "duplicate identifier", .{});
|
|
} else {
|
|
gop.value_ptr.* = .{
|
|
.tag = .stitch,
|
|
.decl_inst = extra.value,
|
|
.args_count = 0,
|
|
.namespace = child_namespace,
|
|
};
|
|
}
|
|
try sema.module.queueWorkItem(.{
|
|
.tag = .stitch,
|
|
.decl_name = decl_name,
|
|
.inst_index = extra.value,
|
|
.namespace = child_namespace,
|
|
});
|
|
},
|
|
.decl_function => {
|
|
const child_namespace = try sema.module.createNamespace(namespace);
|
|
const gop = try namespace.decls.getOrPut(sema.arena, decl_name);
|
|
if (gop.found_existing) {
|
|
return sema.fail(src_loc, "duplicate identifier", .{});
|
|
} else {
|
|
gop.value_ptr.* = .{
|
|
.tag = .function,
|
|
.decl_inst = extra.value,
|
|
.args_count = 0,
|
|
.namespace = child_namespace,
|
|
};
|
|
}
|
|
try sema.module.queueWorkItem(.{
|
|
.tag = .function,
|
|
.decl_name = decl_name,
|
|
.inst_index = extra.value,
|
|
.namespace = child_namespace,
|
|
});
|
|
},
|
|
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
fn resolveGlobalDecl(
|
|
sema: *Sema,
|
|
builder: *Builder,
|
|
decl_name: InternPool.Index,
|
|
src_loc: SrcLoc,
|
|
) InnerError!ValueInfo {
|
|
const entry = builder.namespace.decls.getPtr(decl_name).?;
|
|
switch (entry.resolution) {
|
|
.unresolved => {
|
|
const data = sema.ir.instructions[@intFromEnum(entry.decl_inst)].data.payload;
|
|
const extra = sema.ir.extraData(Ir.Inst.Var, data.extra_index);
|
|
const body = sema.ir.bodySlice(extra.end, extra.data.body_len);
|
|
|
|
entry.resolution = .in_progress;
|
|
const val = try sema.analyzeBodyInner(builder, body, true);
|
|
entry.resolution = .{ .resolved = val };
|
|
return val;
|
|
},
|
|
.in_progress => return sema.fail(
|
|
src_loc,
|
|
"cycle detected in constant initializer",
|
|
.{},
|
|
),
|
|
.resolved => |val| return val,
|
|
}
|
|
}
|
|
|
|
pub fn scanTopLevelDecls(
|
|
sema: *Sema,
|
|
namespace: *Module.Namespace,
|
|
decls: []const Ir.Inst.Index,
|
|
) !void {
|
|
const gpa = sema.gpa;
|
|
for (decls) |decl_index| {
|
|
try sema.scanTopLevelDecl(namespace, decl_index);
|
|
}
|
|
|
|
var builder: Builder = .{
|
|
.sema = sema,
|
|
.code = undefined,
|
|
.namespace = namespace,
|
|
};
|
|
defer builder.deinit(gpa);
|
|
|
|
var iter = namespace.decls.iterator();
|
|
while (iter.next()) |entry| {
|
|
const key = entry.key_ptr.*;
|
|
const value = entry.value_ptr.*;
|
|
switch (value.tag) {
|
|
.var_mut, .var_const => {
|
|
// TODO: Set a proper source offset for this.
|
|
const src_loc: SrcLoc = .{ .src_offset = 0 };
|
|
const result = try sema.resolveGlobalDecl(&builder, key, src_loc);
|
|
const initial_value = sema.resolveValue(result).?;
|
|
try sema.module.globals.append(gpa, .{
|
|
.key = key,
|
|
.value = initial_value.toInterned(),
|
|
});
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
}
|