commit f2feb4e47aa7d74f26f5bda1f8383ccd0f54026a (tree)
parent 64f4ef75566ef34289e9e6a455b0173e4e58df47
Author: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 15 May 2020 21:44:33 -0400
move Module to its own file
Diffstat:
8 files changed, 3534 insertions(+), 3525 deletions(-)
diff --git a/src-self-hosted/Module.zig b/src-self-hosted/Module.zig
@@ -0,0 +1,2018 @@
+const std = @import("std");
+const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const ArrayListUnmanaged = std.ArrayListUnmanaged;
+const Value = @import("value.zig").Value;
+const Type = @import("type.zig").Type;
+const TypedValue = @import("TypedValue.zig");
+const assert = std.debug.assert;
+const BigIntConst = std.math.big.int.Const;
+const BigIntMutable = std.math.big.int.Mutable;
+const Target = std.Target;
+const Package = @import("Package.zig");
+const link = @import("link.zig");
+const ir = @import("ir.zig");
+const zir = @import("zir.zig");
+const Module = @This();
+const Inst = ir.Inst;
+
+/// General-purpose allocator.
+allocator: *Allocator,
+/// Module owns this resource.
+root_pkg: *Package,
+/// Module owns this resource.
+root_scope: *Scope.ZIRModule,
+/// Pointer to externally managed resource.
+bin_file: *link.ElfFile,
+/// It's rare for a decl to be exported, so we save memory by having a sparse map of
+/// Decl pointers to details about them being exported.
+/// The Export memory is owned by the `export_owners` table; the slice itself is owned by this table.
+decl_exports: std.AutoHashMap(*Decl, []*Export),
+/// This models the Decls that perform exports, so that `decl_exports` can be updated when a Decl
+/// is modified. Note that the key of this table is not the Decl being exported, but the Decl that
+/// is performing the export of another Decl.
+/// This table owns the Export memory.
+export_owners: std.AutoHashMap(*Decl, []*Export),
+/// Maps fully qualified namespaced names to the Decl struct for them.
+decl_table: std.AutoHashMap(Decl.Hash, *Decl),
+
+optimize_mode: std.builtin.Mode,
+link_error_flags: link.ElfFile.ErrorFlags = link.ElfFile.ErrorFlags{},
+
+work_queue: std.fifo.LinearFifo(WorkItem, .Dynamic),
+
+/// We optimize memory usage for a compilation with no compile errors by storing the
+/// error messages and mapping outside of `Decl`.
+/// The ErrorMsg memory is owned by the decl, using Module's allocator.
+/// Note that a Decl can succeed but the Fn it represents can fail. In this case,
+/// a Decl can have a failed_decls entry but have analysis status of success.
+failed_decls: std.AutoHashMap(*Decl, *ErrorMsg),
+/// Using a map here for consistency with the other fields here.
+/// The ErrorMsg memory is owned by the `Scope.ZIRModule`, using Module's allocator.
+failed_files: std.AutoHashMap(*Scope.ZIRModule, *ErrorMsg),
+/// Using a map here for consistency with the other fields here.
+/// The ErrorMsg memory is owned by the `Export`, using Module's allocator.
+failed_exports: std.AutoHashMap(*Export, *ErrorMsg),
+
+pub const WorkItem = union(enum) {
+ /// Write the machine code for a Decl to the output file.
+ codegen_decl: *Decl,
+};
+
+pub const Export = struct {
+ options: std.builtin.ExportOptions,
+ /// Byte offset into the file that contains the export directive.
+ src: usize,
+ /// Represents the position of the export, if any, in the output file.
+ link: link.ElfFile.Export,
+ /// The Decl that performs the export. Note that this is *not* the Decl being exported.
+ owner_decl: *Decl,
+ status: enum {
+ in_progress,
+ failed,
+ /// Indicates that the failure was due to a temporary issue, such as an I/O error
+ /// when writing to the output file. Retrying the export may succeed.
+ failed_retryable,
+ complete,
+ },
+};
+
+pub const Decl = struct {
+ /// This name is relative to the containing namespace of the decl. It uses a null-termination
+ /// to save bytes, since there can be a lot of decls in a compilation. The null byte is not allowed
+ /// in symbol names, because executable file formats use null-terminated strings for symbol names.
+ /// All Decls have names, even values that are not bound to a zig namespace. This is necessary for
+ /// mapping them to an address in the output file.
+ /// Memory owned by this decl, using Module's allocator.
+ name: [*:0]const u8,
+ /// The direct parent container of the Decl. This field will need to get more fleshed out when
+ /// self-hosted supports proper struct types and Zig AST => ZIR.
+ /// Reference to externally owned memory.
+ scope: *Scope.ZIRModule,
+ /// Byte offset into the source file that contains this declaration.
+ /// This is the base offset that src offsets within this Decl are relative to.
+ src: usize,
+ /// The most recent value of the Decl after a successful semantic analysis.
+ /// The tag for this union is determined by the tag value of the analysis field.
+ typed_value: union {
+ never_succeeded: void,
+ most_recent: TypedValue.Managed,
+ },
+ /// Represents the "shallow" analysis status. For example, for decls that are functions,
+ /// the function type is analyzed with this set to `in_progress`, however, the semantic
+ /// analysis of the function body is performed with this value set to `success`. Functions
+ /// have their own analysis status field.
+ analysis: enum {
+ initial_in_progress,
+ /// This Decl might be OK but it depends on another one which did not successfully complete
+ /// semantic analysis. This Decl never had a value computed.
+ initial_dependency_failure,
+ /// Semantic analysis failure. This Decl never had a value computed.
+ /// There will be a corresponding ErrorMsg in Module.failed_decls.
+ initial_sema_failure,
+ /// In this case the `typed_value.most_recent` can still be accessed.
+ /// There will be a corresponding ErrorMsg in Module.failed_decls.
+ codegen_failure,
+ /// In this case the `typed_value.most_recent` can still be accessed.
+ /// There will be a corresponding ErrorMsg in Module.failed_decls.
+ /// This indicates the failure was something like running out of disk space,
+ /// and attempting codegen again may succeed.
+ codegen_failure_retryable,
+ /// This Decl might be OK but it depends on another one which did not successfully complete
+ /// semantic analysis. There is a most recent value available.
+ repeat_dependency_failure,
+ /// Semantic anlaysis failure, but the `typed_value.most_recent` can be accessed.
+ /// There will be a corresponding ErrorMsg in Module.failed_decls.
+ repeat_sema_failure,
+ /// Completed successfully before; the `typed_value.most_recent` can be accessed, and
+ /// new semantic analysis is in progress.
+ repeat_in_progress,
+ /// Everything is done and updated.
+ complete,
+ },
+
+ /// Represents the position of the code in the output file.
+ /// This is populated regardless of semantic analysis and code generation.
+ link: link.ElfFile.Decl = link.ElfFile.Decl.empty,
+
+ /// The shallow set of other decls whose typed_value could possibly change if this Decl's
+ /// typed_value is modified.
+ /// TODO look into using a lightweight map/set data structure rather than a linear array.
+ dependants: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
+
+ contents_hash: Hash,
+
+ pub fn destroy(self: *Decl, allocator: *Allocator) void {
+ allocator.free(mem.spanZ(self.name));
+ if (self.typedValueManaged()) |tvm| {
+ tvm.deinit(allocator);
+ }
+ allocator.destroy(self);
+ }
+
+ pub const Hash = [16]u8;
+
+ /// If the name is small enough, it is used directly as the hash.
+ /// If it is long, blake3 hash is computed.
+ pub fn hashSimpleName(name: []const u8) Hash {
+ var out: Hash = undefined;
+ if (name.len <= Hash.len) {
+ mem.copy(u8, &out, name);
+ mem.set(u8, out[name.len..], 0);
+ } else {
+ std.crypto.Blake3.hash(name, &out);
+ }
+ return out;
+ }
+
+ /// Must generate unique bytes with no collisions with other decls.
+ /// The point of hashing here is only to limit the number of bytes of
+ /// the unique identifier to a fixed size (16 bytes).
+ pub fn fullyQualifiedNameHash(self: Decl) Hash {
+ // Right now we only have ZIRModule as the source. So this is simply the
+ // relative name of the decl.
+ return hashSimpleName(mem.spanZ(u8, self.name));
+ }
+
+ pub fn typedValue(self: *Decl) error{AnalysisFail}!TypedValue {
+ const tvm = self.typedValueManaged() orelse return error.AnalysisFail;
+ return tvm.typed_value;
+ }
+
+ pub fn value(self: *Decl) error{AnalysisFail}!Value {
+ return (try self.typedValue()).val;
+ }
+
+ pub fn dump(self: *Decl) void {
+ const loc = std.zig.findLineColumn(self.scope.source.bytes, self.src);
+ std.debug.warn("{}:{}:{} name={} status={}", .{
+ self.scope.sub_file_path,
+ loc.line + 1,
+ loc.column + 1,
+ mem.spanZ(self.name),
+ @tagName(self.analysis),
+ });
+ if (self.typedValueManaged()) |tvm| {
+ std.debug.warn(" ty={} val={}", .{ tvm.typed_value.ty, tvm.typed_value.val });
+ }
+ std.debug.warn("\n", .{});
+ }
+
+ fn typedValueManaged(self: *Decl) ?*TypedValue.Managed {
+ switch (self.analysis) {
+ .initial_in_progress,
+ .initial_dependency_failure,
+ .initial_sema_failure,
+ => return null,
+ .codegen_failure,
+ .codegen_failure_retryable,
+ .repeat_dependency_failure,
+ .repeat_sema_failure,
+ .repeat_in_progress,
+ .complete,
+ => return &self.typed_value.most_recent,
+ }
+ }
+};
+
+/// Fn struct memory is owned by the Decl's TypedValue.Managed arena allocator.
+pub const Fn = struct {
+ /// This memory owned by the Decl's TypedValue.Managed arena allocator.
+ fn_type: Type,
+ analysis: union(enum) {
+ /// The value is the source instruction.
+ queued: *zir.Inst.Fn,
+ in_progress: *Analysis,
+ /// There will be a corresponding ErrorMsg in Module.failed_decls
+ sema_failure,
+ /// This Fn might be OK but it depends on another Decl which did not successfully complete
+ /// semantic analysis.
+ dependency_failure,
+ success: Body,
+ },
+
+ /// This memory is temporary and points to stack memory for the duration
+ /// of Fn analysis.
+ pub const Analysis = struct {
+ inner_block: Scope.Block,
+ /// TODO Performance optimization idea: instead of this inst_table,
+ /// use a field in the zir.Inst instead to track corresponding instructions
+ inst_table: std.AutoHashMap(*zir.Inst, *Inst),
+ needed_inst_capacity: usize,
+ };
+};
+
+pub const Scope = struct {
+ tag: Tag,
+
+ pub fn cast(base: *Scope, comptime T: type) ?*T {
+ if (base.tag != T.base_tag)
+ return null;
+
+ return @fieldParentPtr(T, "base", base);
+ }
+
+ /// Asserts the scope has a parent which is a DeclAnalysis and
+ /// returns the arena Allocator.
+ pub fn arena(self: *Scope) *Allocator {
+ switch (self.tag) {
+ .block => return self.cast(Block).?.arena,
+ .decl => return &self.cast(DeclAnalysis).?.arena.allocator,
+ .zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
+ }
+ }
+
+ /// Asserts the scope has a parent which is a DeclAnalysis and
+ /// returns the Decl.
+ pub fn decl(self: *Scope) *Decl {
+ switch (self.tag) {
+ .block => return self.cast(Block).?.decl,
+ .decl => return self.cast(DeclAnalysis).?.decl,
+ .zir_module => unreachable,
+ }
+ }
+
+ /// Asserts the scope has a parent which is a ZIRModule and
+ /// returns it.
+ pub fn namespace(self: *Scope) *ZIRModule {
+ switch (self.tag) {
+ .block => return self.cast(Block).?.decl.scope,
+ .decl => return self.cast(DeclAnalysis).?.decl.scope,
+ .zir_module => return self.cast(ZIRModule).?,
+ }
+ }
+
+ pub fn dumpInst(self: *Scope, inst: *Inst) void {
+ const zir_module = self.namespace();
+ const loc = std.zig.findLineColumn(zir_module.source.bytes, inst.src);
+ std.debug.warn("{}:{}:{}: {}: ty={}\n", .{
+ zir_module.sub_file_path,
+ loc.line + 1,
+ loc.column + 1,
+ @tagName(inst.tag),
+ inst.ty,
+ });
+ }
+
+ pub const Tag = enum {
+ zir_module,
+ block,
+ decl,
+ };
+
+ pub const ZIRModule = struct {
+ pub const base_tag: Tag = .zir_module;
+ base: Scope = Scope{ .tag = base_tag },
+ /// Relative to the owning package's root_src_dir.
+ /// Reference to external memory, not owned by ZIRModule.
+ sub_file_path: []const u8,
+ source: union {
+ unloaded: void,
+ bytes: [:0]const u8,
+ },
+ contents: union {
+ not_available: void,
+ module: *zir.Module,
+ },
+ status: enum {
+ never_loaded,
+ unloaded_success,
+ unloaded_parse_failure,
+ unloaded_sema_failure,
+ loaded_parse_failure,
+ loaded_sema_failure,
+ loaded_success,
+ },
+
+ pub fn unload(self: *ZIRModule, allocator: *Allocator) void {
+ switch (self.status) {
+ .never_loaded,
+ .unloaded_parse_failure,
+ .unloaded_sema_failure,
+ .unloaded_success,
+ => {},
+
+ .loaded_success => {
+ allocator.free(self.source.bytes);
+ self.contents.module.deinit(allocator);
+ allocator.destroy(self.contents.module);
+ self.status = .unloaded_success;
+ },
+ .loaded_sema_failure => {
+ allocator.free(self.source.bytes);
+ self.contents.module.deinit(allocator);
+ allocator.destroy(self.contents.module);
+ self.status = .unloaded_sema_failure;
+ },
+ .loaded_parse_failure => {
+ allocator.free(self.source.bytes);
+ self.status = .unloaded_parse_failure;
+ },
+ }
+ }
+
+ pub fn deinit(self: *ZIRModule, allocator: *Allocator) void {
+ self.unload(allocator);
+ self.* = undefined;
+ }
+
+ pub fn dumpSrc(self: *ZIRModule, src: usize) void {
+ const loc = std.zig.findLineColumn(self.source.bytes, src);
+ std.debug.warn("{}:{}:{}\n", .{ self.sub_file_path, loc.line + 1, loc.column + 1 });
+ }
+ };
+
+ /// This is a temporary structure, references to it are valid only
+ /// during semantic analysis of the block.
+ pub const Block = struct {
+ pub const base_tag: Tag = .block;
+ base: Scope = Scope{ .tag = base_tag },
+ func: *Fn,
+ decl: *Decl,
+ instructions: ArrayListUnmanaged(*Inst),
+ /// Points to the arena allocator of DeclAnalysis
+ arena: *Allocator,
+ };
+
+ /// This is a temporary structure, references to it are valid only
+ /// during semantic analysis of the decl.
+ pub const DeclAnalysis = struct {
+ pub const base_tag: Tag = .decl;
+ base: Scope = Scope{ .tag = base_tag },
+ decl: *Decl,
+ arena: std.heap.ArenaAllocator,
+ };
+};
+
+pub const Body = struct {
+ instructions: []*Inst,
+};
+
+pub const AllErrors = struct {
+ arena: std.heap.ArenaAllocator.State,
+ list: []const Message,
+
+ pub const Message = struct {
+ src_path: []const u8,
+ line: usize,
+ column: usize,
+ byte_offset: usize,
+ msg: []const u8,
+ };
+
+ pub fn deinit(self: *AllErrors, allocator: *Allocator) void {
+ self.arena.promote(allocator).deinit();
+ }
+
+ fn add(
+ arena: *std.heap.ArenaAllocator,
+ errors: *std.ArrayList(Message),
+ sub_file_path: []const u8,
+ source: []const u8,
+ simple_err_msg: ErrorMsg,
+ ) !void {
+ const loc = std.zig.findLineColumn(source, simple_err_msg.byte_offset);
+ try errors.append(.{
+ .src_path = try arena.allocator.dupe(u8, sub_file_path),
+ .msg = try arena.allocator.dupe(u8, simple_err_msg.msg),
+ .byte_offset = simple_err_msg.byte_offset,
+ .line = loc.line,
+ .column = loc.column,
+ });
+ }
+};
+
+pub fn deinit(self: *Module) void {
+ const allocator = self.allocator;
+ self.work_queue.deinit();
+ {
+ var it = self.decl_table.iterator();
+ while (it.next()) |kv| {
+ kv.value.destroy(allocator);
+ }
+ self.decl_table.deinit();
+ }
+ {
+ var it = self.failed_decls.iterator();
+ while (it.next()) |kv| {
+ kv.value.destroy(allocator);
+ }
+ self.failed_decls.deinit();
+ }
+ {
+ var it = self.failed_files.iterator();
+ while (it.next()) |kv| {
+ kv.value.destroy(allocator);
+ }
+ self.failed_files.deinit();
+ }
+ {
+ var it = self.failed_exports.iterator();
+ while (it.next()) |kv| {
+ kv.value.destroy(allocator);
+ }
+ self.failed_exports.deinit();
+ }
+ {
+ var it = self.decl_exports.iterator();
+ while (it.next()) |kv| {
+ const export_list = kv.value;
+ allocator.free(export_list);
+ }
+ self.decl_exports.deinit();
+ }
+ {
+ var it = self.export_owners.iterator();
+ while (it.next()) |kv| {
+ const export_list = kv.value;
+ for (export_list) |exp| {
+ allocator.destroy(exp);
+ }
+ allocator.free(export_list);
+ }
+ self.export_owners.deinit();
+ }
+ self.root_pkg.destroy();
+ {
+ self.root_scope.deinit(allocator);
+ allocator.destroy(self.root_scope);
+ }
+ self.* = undefined;
+}
+
+pub fn target(self: Module) std.Target {
+ return self.bin_file.options.target;
+}
+
+/// Detect changes to source files, perform semantic analysis, and update the output files.
+pub fn update(self: *Module) !void {
+ // TODO Use the cache hash file system to detect which source files changed.
+ // Here we simulate a full cache miss.
+ // Analyze the root source file now.
+ self.analyzeRoot(self.root_scope) catch |err| switch (err) {
+ error.AnalysisFail => {
+ assert(self.totalErrorCount() != 0);
+ },
+ else => |e| return e,
+ };
+
+ try self.performAllTheWork();
+
+ // Unload all the source files from memory.
+ self.root_scope.unload(self.allocator);
+
+ try self.bin_file.flush();
+ self.link_error_flags = self.bin_file.error_flags;
+}
+
+pub fn totalErrorCount(self: *Module) usize {
+ return self.failed_decls.size +
+ self.failed_files.size +
+ self.failed_exports.size +
+ @boolToInt(self.link_error_flags.no_entry_point_found);
+}
+
+pub fn getAllErrorsAlloc(self: *Module) !AllErrors {
+ var arena = std.heap.ArenaAllocator.init(self.allocator);
+ errdefer arena.deinit();
+
+ var errors = std.ArrayList(AllErrors.Message).init(self.allocator);
+ defer errors.deinit();
+
+ {
+ var it = self.failed_files.iterator();
+ while (it.next()) |kv| {
+ const scope = kv.key;
+ const err_msg = kv.value;
+ const source = scope.source.bytes;
+ try AllErrors.add(&arena, &errors, scope.sub_file_path, source, err_msg.*);
+ }
+ }
+ {
+ var it = self.failed_decls.iterator();
+ while (it.next()) |kv| {
+ const decl = kv.key;
+ const err_msg = kv.value;
+ const source = decl.scope.source.bytes;
+ try AllErrors.add(&arena, &errors, decl.scope.sub_file_path, source, err_msg.*);
+ }
+ }
+ {
+ var it = self.failed_exports.iterator();
+ while (it.next()) |kv| {
+ const decl = kv.key.owner_decl;
+ const err_msg = kv.value;
+ const source = decl.scope.source.bytes;
+ try AllErrors.add(&arena, &errors, decl.scope.sub_file_path, source, err_msg.*);
+ }
+ }
+
+ if (self.link_error_flags.no_entry_point_found) {
+ try errors.append(.{
+ .src_path = self.root_pkg.root_src_path,
+ .line = 0,
+ .column = 0,
+ .byte_offset = 0,
+ .msg = try std.fmt.allocPrint(&arena.allocator, "no entry point found", .{}),
+ });
+ }
+
+ assert(errors.items.len == self.totalErrorCount());
+
+ return AllErrors{
+ .arena = arena.state,
+ .list = try arena.allocator.dupe(AllErrors.Message, errors.items),
+ };
+}
+
+const InnerError = error{ OutOfMemory, AnalysisFail };
+
+pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
+ while (self.work_queue.readItem()) |work_item| switch (work_item) {
+ .codegen_decl => |decl| switch (decl.analysis) {
+ .initial_in_progress,
+ .repeat_in_progress,
+ => unreachable,
+
+ .initial_sema_failure,
+ .repeat_sema_failure,
+ .codegen_failure,
+ .initial_dependency_failure,
+ .repeat_dependency_failure,
+ => continue,
+
+ .complete, .codegen_failure_retryable => {
+ if (decl.typed_value.most_recent.typed_value.val.cast(Value.Payload.Function)) |payload| {
+ switch (payload.func.analysis) {
+ .queued => self.analyzeFnBody(decl, payload.func) catch |err| switch (err) {
+ error.AnalysisFail => {
+ if (payload.func.analysis == .queued) {
+ payload.func.analysis = .dependency_failure;
+ }
+ continue;
+ },
+ else => |e| return e,
+ },
+ .in_progress => unreachable,
+ .sema_failure, .dependency_failure => continue,
+ .success => {},
+ }
+ }
+
+ assert(decl.typed_value.most_recent.typed_value.ty.hasCodeGenBits());
+
+ self.bin_file.updateDecl(self, decl) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ error.AnalysisFail => {
+ decl.analysis = .repeat_dependency_failure;
+ },
+ else => {
+ try self.failed_decls.ensureCapacity(self.failed_decls.size + 1);
+ self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
+ self.allocator,
+ decl.src,
+ "unable to codegen: {}",
+ .{@errorName(err)},
+ ));
+ decl.analysis = .codegen_failure_retryable;
+ },
+ };
+ },
+ },
+ };
+}
+
+fn getSrcModule(self: *Module, root_scope: *Scope.ZIRModule) !*zir.Module {
+ switch (root_scope.status) {
+ .never_loaded, .unloaded_success => {
+ try self.failed_files.ensureCapacity(self.failed_files.size + 1);
+
+ var keep_source = false;
+ const source = try self.root_pkg.root_src_dir.readFileAllocOptions(
+ self.allocator,
+ self.root_pkg.root_src_path,
+ std.math.maxInt(u32),
+ 1,
+ 0,
+ );
+ defer if (!keep_source) self.allocator.free(source);
+
+ var keep_zir_module = false;
+ const zir_module = try self.allocator.create(zir.Module);
+ defer if (!keep_zir_module) self.allocator.destroy(zir_module);
+
+ zir_module.* = try zir.parse(self.allocator, source);
+ defer if (!keep_zir_module) zir_module.deinit(self.allocator);
+
+ if (zir_module.error_msg) |src_err_msg| {
+ self.failed_files.putAssumeCapacityNoClobber(
+ root_scope,
+ try ErrorMsg.create(self.allocator, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
+ );
+ root_scope.status = .loaded_parse_failure;
+ root_scope.source = .{ .bytes = source };
+ keep_source = true;
+ return error.AnalysisFail;
+ }
+
+ root_scope.status = .loaded_success;
+ root_scope.source = .{ .bytes = source };
+ keep_source = true;
+ root_scope.contents = .{ .module = zir_module };
+ keep_zir_module = true;
+
+ return zir_module;
+ },
+
+ .unloaded_parse_failure,
+ .unloaded_sema_failure,
+ .loaded_parse_failure,
+ .loaded_sema_failure,
+ => return error.AnalysisFail,
+ .loaded_success => return root_scope.contents.module,
+ }
+}
+
+fn analyzeRoot(self: *Module, root_scope: *Scope.ZIRModule) !void {
+ // TODO use the cache to identify, from the modified source files, the decls which have
+ // changed based on the span of memory that represents the decl in the re-parsed source file.
+ // Use the cached dependency graph to recursively determine the set of decls which need
+ // regeneration.
+ // Here we simulate adding a source file which was previously not part of the compilation,
+ // which means scanning the decls looking for exports.
+ // TODO also identify decls that need to be deleted.
+ switch (root_scope.status) {
+ .never_loaded => {
+ const src_module = try self.getSrcModule(root_scope);
+
+ // Here we ensure enough queue capacity to store all the decls, so that later we can use
+ // appendAssumeCapacity.
+ try self.work_queue.ensureUnusedCapacity(src_module.decls.len);
+
+ for (src_module.decls) |decl| {
+ if (decl.cast(zir.Inst.Export)) |export_inst| {
+ _ = try self.resolveDecl(&root_scope.base, &export_inst.base, link.ElfFile.Decl.empty);
+ }
+ }
+ },
+
+ .unloaded_parse_failure,
+ .unloaded_sema_failure,
+ .loaded_parse_failure,
+ .loaded_sema_failure,
+ .loaded_success,
+ .unloaded_success,
+ => {
+ const src_module = try self.getSrcModule(root_scope);
+
+ // Look for changed decls.
+ for (src_module.decls) |src_decl| {
+ const name_hash = Decl.hashSimpleName(src_decl.name);
+ if (self.decl_table.get(name_hash)) |kv| {
+ const decl = kv.value;
+ const new_contents_hash = Decl.hashSimpleName(src_decl.contents);
+ if (!mem.eql(u8, &new_contents_hash, &decl.contents_hash)) {
+ // TODO recursive dependency management
+ std.debug.warn("noticed that '{}' changed\n", .{src_decl.name});
+ self.decl_table.removeAssertDiscard(name_hash);
+ const saved_link = decl.link;
+ decl.destroy(self.allocator);
+ if (self.export_owners.getValue(decl)) |exports| {
+ @panic("TODO handle updating a decl that does an export");
+ }
+ const new_decl = self.resolveDecl(
+ &root_scope.base,
+ src_decl,
+ saved_link,
+ ) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ error.AnalysisFail => continue,
+ };
+ if (self.decl_exports.remove(decl)) |entry| {
+ self.decl_exports.putAssumeCapacityNoClobber(new_decl, entry.value);
+ }
+ }
+ } else if (src_decl.cast(zir.Inst.Export)) |export_inst| {
+ _ = try self.resolveDecl(&root_scope.base, &export_inst.base, link.ElfFile.Decl.empty);
+ }
+ }
+ },
+ }
+}
+
+fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
+ // Use the Decl's arena for function memory.
+ var arena = decl.typed_value.most_recent.arena.?.promote(self.allocator);
+ defer decl.typed_value.most_recent.arena.?.* = arena.state;
+ var analysis: Fn.Analysis = .{
+ .inner_block = .{
+ .func = func,
+ .decl = decl,
+ .instructions = .{},
+ .arena = &arena.allocator,
+ },
+ .needed_inst_capacity = 0,
+ .inst_table = std.AutoHashMap(*zir.Inst, *Inst).init(self.allocator),
+ };
+ defer analysis.inner_block.instructions.deinit(self.allocator);
+ defer analysis.inst_table.deinit();
+
+ const fn_inst = func.analysis.queued;
+ func.analysis = .{ .in_progress = &analysis };
+
+ try self.analyzeBody(&analysis.inner_block.base, fn_inst.positionals.body);
+
+ func.analysis = .{
+ .success = .{
+ .instructions = try arena.allocator.dupe(*Inst, analysis.inner_block.instructions.items),
+ },
+ };
+}
+
+fn resolveDecl(
+ self: *Module,
+ scope: *Scope,
+ old_inst: *zir.Inst,
+ bin_file_link: link.ElfFile.Decl,
+) InnerError!*Decl {
+ const hash = Decl.hashSimpleName(old_inst.name);
+ if (self.decl_table.get(hash)) |kv| {
+ return kv.value;
+ } else {
+ const new_decl = blk: {
+ try self.decl_table.ensureCapacity(self.decl_table.size + 1);
+ const new_decl = try self.allocator.create(Decl);
+ errdefer self.allocator.destroy(new_decl);
+ const name = try mem.dupeZ(self.allocator, u8, old_inst.name);
+ errdefer self.allocator.free(name);
+ new_decl.* = .{
+ .name = name,
+ .scope = scope.namespace(),
+ .src = old_inst.src,
+ .typed_value = .{ .never_succeeded = {} },
+ .analysis = .initial_in_progress,
+ .contents_hash = Decl.hashSimpleName(old_inst.contents),
+ .link = bin_file_link,
+ };
+ self.decl_table.putAssumeCapacityNoClobber(hash, new_decl);
+ break :blk new_decl;
+ };
+
+ var decl_scope: Scope.DeclAnalysis = .{
+ .decl = new_decl,
+ .arena = std.heap.ArenaAllocator.init(self.allocator),
+ };
+ errdefer decl_scope.arena.deinit();
+
+ const typed_value = self.analyzeInstConst(&decl_scope.base, old_inst) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ error.AnalysisFail => {
+ switch (new_decl.analysis) {
+ .initial_in_progress => new_decl.analysis = .initial_dependency_failure,
+ .repeat_in_progress => new_decl.analysis = .repeat_dependency_failure,
+ else => {},
+ }
+ return error.AnalysisFail;
+ },
+ };
+ const arena_state = try decl_scope.arena.allocator.create(std.heap.ArenaAllocator.State);
+
+ const has_codegen_bits = typed_value.ty.hasCodeGenBits();
+ if (has_codegen_bits) {
+ // We don't fully codegen the decl until later, but we do need to reserve a global
+ // offset table index for it. This allows us to codegen decls out of dependency order,
+ // increasing how many computations can be done in parallel.
+ try self.bin_file.allocateDeclIndexes(new_decl);
+ }
+
+ arena_state.* = decl_scope.arena.state;
+
+ new_decl.typed_value = .{
+ .most_recent = .{
+ .typed_value = typed_value,
+ .arena = arena_state,
+ },
+ };
+ new_decl.analysis = .complete;
+ if (has_codegen_bits) {
+ // We ensureCapacity when scanning for decls.
+ self.work_queue.writeItemAssumeCapacity(.{ .codegen_decl = new_decl });
+ }
+ return new_decl;
+ }
+}
+
+fn resolveCompleteDecl(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*Decl {
+ const decl = try self.resolveDecl(scope, old_inst, link.ElfFile.Decl.empty);
+ switch (decl.analysis) {
+ .initial_in_progress => unreachable,
+ .repeat_in_progress => unreachable,
+ .initial_dependency_failure,
+ .repeat_dependency_failure,
+ .initial_sema_failure,
+ .repeat_sema_failure,
+ .codegen_failure,
+ .codegen_failure_retryable,
+ => return error.AnalysisFail,
+
+ .complete => return decl,
+ }
+}
+
+fn resolveInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*Inst {
+ if (scope.cast(Scope.Block)) |block| {
+ if (block.func.analysis.in_progress.inst_table.get(old_inst)) |kv| {
+ return kv.value;
+ }
+ }
+
+ const decl = try self.resolveCompleteDecl(scope, old_inst);
+ const decl_ref = try self.analyzeDeclRef(scope, old_inst.src, decl);
+ return self.analyzeDeref(scope, old_inst.src, decl_ref, old_inst.src);
+}
+
+fn requireRuntimeBlock(self: *Module, scope: *Scope, src: usize) !*Scope.Block {
+ return scope.cast(Scope.Block) orelse
+ return self.fail(scope, src, "instruction illegal outside function body", .{});
+}
+
+fn resolveInstConst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!TypedValue {
+ const new_inst = try self.resolveInst(scope, old_inst);
+ const val = try self.resolveConstValue(scope, new_inst);
+ return TypedValue{
+ .ty = new_inst.ty,
+ .val = val,
+ };
+}
+
+fn resolveConstValue(self: *Module, scope: *Scope, base: *Inst) !Value {
+ return (try self.resolveDefinedValue(scope, base)) orelse
+ return self.fail(scope, base.src, "unable to resolve comptime value", .{});
+}
+
+fn resolveDefinedValue(self: *Module, scope: *Scope, base: *Inst) !?Value {
+ if (base.value()) |val| {
+ if (val.isUndef()) {
+ return self.fail(scope, base.src, "use of undefined value here causes undefined behavior", .{});
+ }
+ return val;
+ }
+ return null;
+}
+
+fn resolveConstString(self: *Module, scope: *Scope, old_inst: *zir.Inst) ![]u8 {
+ const new_inst = try self.resolveInst(scope, old_inst);
+ const wanted_type = Type.initTag(.const_slice_u8);
+ const coerced_inst = try self.coerce(scope, wanted_type, new_inst);
+ const val = try self.resolveConstValue(scope, coerced_inst);
+ return val.toAllocatedBytes(scope.arena());
+}
+
+fn resolveType(self: *Module, scope: *Scope, old_inst: *zir.Inst) !Type {
+ const new_inst = try self.resolveInst(scope, old_inst);
+ const wanted_type = Type.initTag(.@"type");
+ const coerced_inst = try self.coerce(scope, wanted_type, new_inst);
+ const val = try self.resolveConstValue(scope, coerced_inst);
+ return val.toType();
+}
+
+fn analyzeExport(self: *Module, scope: *Scope, export_inst: *zir.Inst.Export) InnerError!void {
+ try self.decl_exports.ensureCapacity(self.decl_exports.size + 1);
+ try self.export_owners.ensureCapacity(self.export_owners.size + 1);
+ const symbol_name = try self.resolveConstString(scope, export_inst.positionals.symbol_name);
+ const exported_decl = try self.resolveCompleteDecl(scope, export_inst.positionals.value);
+ const typed_value = exported_decl.typed_value.most_recent.typed_value;
+ switch (typed_value.ty.zigTypeTag()) {
+ .Fn => {},
+ else => return self.fail(
+ scope,
+ export_inst.positionals.value.src,
+ "unable to export type '{}'",
+ .{typed_value.ty},
+ ),
+ }
+ const new_export = try self.allocator.create(Export);
+ errdefer self.allocator.destroy(new_export);
+
+ const owner_decl = scope.decl();
+
+ new_export.* = .{
+ .options = .{ .name = symbol_name },
+ .src = export_inst.base.src,
+ .link = .{},
+ .owner_decl = owner_decl,
+ .status = .in_progress,
+ };
+
+ // Add to export_owners table.
+ const eo_gop = self.export_owners.getOrPut(owner_decl) catch unreachable;
+ if (!eo_gop.found_existing) {
+ eo_gop.kv.value = &[0]*Export{};
+ }
+ eo_gop.kv.value = try self.allocator.realloc(eo_gop.kv.value, eo_gop.kv.value.len + 1);
+ eo_gop.kv.value[eo_gop.kv.value.len - 1] = new_export;
+ errdefer eo_gop.kv.value = self.allocator.shrink(eo_gop.kv.value, eo_gop.kv.value.len - 1);
+
+ // Add to exported_decl table.
+ const de_gop = self.decl_exports.getOrPut(exported_decl) catch unreachable;
+ if (!de_gop.found_existing) {
+ de_gop.kv.value = &[0]*Export{};
+ }
+ de_gop.kv.value = try self.allocator.realloc(de_gop.kv.value, de_gop.kv.value.len + 1);
+ de_gop.kv.value[de_gop.kv.value.len - 1] = new_export;
+ errdefer de_gop.kv.value = self.allocator.shrink(de_gop.kv.value, de_gop.kv.value.len - 1);
+
+ self.bin_file.updateDeclExports(self, exported_decl, de_gop.kv.value) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => {
+ try self.failed_exports.ensureCapacity(self.failed_exports.size + 1);
+ self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
+ self.allocator,
+ export_inst.base.src,
+ "unable to export: {}",
+ .{@errorName(err)},
+ ));
+ new_export.status = .failed_retryable;
+ },
+ };
+}
+
+/// TODO should not need the cast on the last parameter at the callsites
+fn addNewInstArgs(
+ self: *Module,
+ block: *Scope.Block,
+ src: usize,
+ ty: Type,
+ comptime T: type,
+ args: Inst.Args(T),
+) !*Inst {
+ const inst = try self.addNewInst(block, src, ty, T);
+ inst.args = args;
+ return &inst.base;
+}
+
+fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime T: type) !*T {
+ const inst = try block.arena.create(T);
+ inst.* = .{
+ .base = .{
+ .tag = T.base_tag,
+ .ty = ty,
+ .src = src,
+ },
+ .args = undefined,
+ };
+ try block.instructions.append(self.allocator, &inst.base);
+ return inst;
+}
+
+fn constInst(self: *Module, scope: *Scope, src: usize, typed_value: TypedValue) !*Inst {
+ const const_inst = try scope.arena().create(Inst.Constant);
+ const_inst.* = .{
+ .base = .{
+ .tag = Inst.Constant.base_tag,
+ .ty = typed_value.ty,
+ .src = src,
+ },
+ .val = typed_value.val,
+ };
+ return &const_inst.base;
+}
+
+fn constStr(self: *Module, scope: *Scope, src: usize, str: []const u8) !*Inst {
+ const ty_payload = try scope.arena().create(Type.Payload.Array_u8_Sentinel0);
+ ty_payload.* = .{ .len = str.len };
+
+ const bytes_payload = try scope.arena().create(Value.Payload.Bytes);
+ bytes_payload.* = .{ .data = str };
+
+ return self.constInst(scope, src, .{
+ .ty = Type.initPayload(&ty_payload.base),
+ .val = Value.initPayload(&bytes_payload.base),
+ });
+}
+
+fn constType(self: *Module, scope: *Scope, src: usize, ty: Type) !*Inst {
+ return self.constInst(scope, src, .{
+ .ty = Type.initTag(.type),
+ .val = try ty.toValue(scope.arena()),
+ });
+}
+
+fn constVoid(self: *Module, scope: *Scope, src: usize) !*Inst {
+ return self.constInst(scope, src, .{
+ .ty = Type.initTag(.void),
+ .val = Value.initTag(.the_one_possible_value),
+ });
+}
+
+fn constUndef(self: *Module, scope: *Scope, src: usize, ty: Type) !*Inst {
+ return self.constInst(scope, src, .{
+ .ty = ty,
+ .val = Value.initTag(.undef),
+ });
+}
+
+fn constBool(self: *Module, scope: *Scope, src: usize, v: bool) !*Inst {
+ return self.constInst(scope, src, .{
+ .ty = Type.initTag(.bool),
+ .val = ([2]Value{ Value.initTag(.bool_false), Value.initTag(.bool_true) })[@boolToInt(v)],
+ });
+}
+
+fn constIntUnsigned(self: *Module, scope: *Scope, src: usize, ty: Type, int: u64) !*Inst {
+ const int_payload = try scope.arena().create(Value.Payload.Int_u64);
+ int_payload.* = .{ .int = int };
+
+ return self.constInst(scope, src, .{
+ .ty = ty,
+ .val = Value.initPayload(&int_payload.base),
+ });
+}
+
+fn constIntSigned(self: *Module, scope: *Scope, src: usize, ty: Type, int: i64) !*Inst {
+ const int_payload = try scope.arena().create(Value.Payload.Int_i64);
+ int_payload.* = .{ .int = int };
+
+ return self.constInst(scope, src, .{
+ .ty = ty,
+ .val = Value.initPayload(&int_payload.base),
+ });
+}
+
+fn constIntBig(self: *Module, scope: *Scope, src: usize, ty: Type, big_int: BigIntConst) !*Inst {
+ const val_payload = if (big_int.positive) blk: {
+ if (big_int.to(u64)) |x| {
+ return self.constIntUnsigned(scope, src, ty, x);
+ } else |err| switch (err) {
+ error.NegativeIntoUnsigned => unreachable,
+ error.TargetTooSmall => {}, // handled below
+ }
+ const big_int_payload = try scope.arena().create(Value.Payload.IntBigPositive);
+ big_int_payload.* = .{ .limbs = big_int.limbs };
+ break :blk &big_int_payload.base;
+ } else blk: {
+ if (big_int.to(i64)) |x| {
+ return self.constIntSigned(scope, src, ty, x);
+ } else |err| switch (err) {
+ error.NegativeIntoUnsigned => unreachable,
+ error.TargetTooSmall => {}, // handled below
+ }
+ const big_int_payload = try scope.arena().create(Value.Payload.IntBigNegative);
+ big_int_payload.* = .{ .limbs = big_int.limbs };
+ break :blk &big_int_payload.base;
+ };
+
+ return self.constInst(scope, src, .{
+ .ty = ty,
+ .val = Value.initPayload(val_payload),
+ });
+}
+
+fn analyzeInstConst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!TypedValue {
+ const new_inst = try self.analyzeInst(scope, old_inst);
+ return TypedValue{
+ .ty = new_inst.ty,
+ .val = try self.resolveConstValue(scope, new_inst),
+ };
+}
+
+fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*Inst {
+ switch (old_inst.tag) {
+ .breakpoint => return self.analyzeInstBreakpoint(scope, old_inst.cast(zir.Inst.Breakpoint).?),
+ .call => return self.analyzeInstCall(scope, old_inst.cast(zir.Inst.Call).?),
+ .declref => return self.analyzeInstDeclRef(scope, old_inst.cast(zir.Inst.DeclRef).?),
+ .str => {
+ const bytes = old_inst.cast(zir.Inst.Str).?.positionals.bytes;
+ // The bytes references memory inside the ZIR module, which can get deallocated
+ // after semantic analysis is complete. We need the memory to be in the Decl's arena.
+ const arena_bytes = try scope.arena().dupe(u8, bytes);
+ return self.constStr(scope, old_inst.src, arena_bytes);
+ },
+ .int => {
+ const big_int = old_inst.cast(zir.Inst.Int).?.positionals.int;
+ return self.constIntBig(scope, old_inst.src, Type.initTag(.comptime_int), big_int);
+ },
+ .ptrtoint => return self.analyzeInstPtrToInt(scope, old_inst.cast(zir.Inst.PtrToInt).?),
+ .fieldptr => return self.analyzeInstFieldPtr(scope, old_inst.cast(zir.Inst.FieldPtr).?),
+ .deref => return self.analyzeInstDeref(scope, old_inst.cast(zir.Inst.Deref).?),
+ .as => return self.analyzeInstAs(scope, old_inst.cast(zir.Inst.As).?),
+ .@"asm" => return self.analyzeInstAsm(scope, old_inst.cast(zir.Inst.Asm).?),
+ .@"unreachable" => return self.analyzeInstUnreachable(scope, old_inst.cast(zir.Inst.Unreachable).?),
+ .@"return" => return self.analyzeInstRet(scope, old_inst.cast(zir.Inst.Return).?),
+ .@"fn" => return self.analyzeInstFn(scope, old_inst.cast(zir.Inst.Fn).?),
+ .@"export" => {
+ try self.analyzeExport(scope, old_inst.cast(zir.Inst.Export).?);
+ return self.constVoid(scope, old_inst.src);
+ },
+ .primitive => return self.analyzeInstPrimitive(scope, old_inst.cast(zir.Inst.Primitive).?),
+ .ref => return self.analyzeInstRef(scope, old_inst.cast(zir.Inst.Ref).?),
+ .fntype => return self.analyzeInstFnType(scope, old_inst.cast(zir.Inst.FnType).?),
+ .intcast => return self.analyzeInstIntCast(scope, old_inst.cast(zir.Inst.IntCast).?),
+ .bitcast => return self.analyzeInstBitCast(scope, old_inst.cast(zir.Inst.BitCast).?),
+ .elemptr => return self.analyzeInstElemPtr(scope, old_inst.cast(zir.Inst.ElemPtr).?),
+ .add => return self.analyzeInstAdd(scope, old_inst.cast(zir.Inst.Add).?),
+ .cmp => return self.analyzeInstCmp(scope, old_inst.cast(zir.Inst.Cmp).?),
+ .condbr => return self.analyzeInstCondBr(scope, old_inst.cast(zir.Inst.CondBr).?),
+ .isnull => return self.analyzeInstIsNull(scope, old_inst.cast(zir.Inst.IsNull).?),
+ .isnonnull => return self.analyzeInstIsNonNull(scope, old_inst.cast(zir.Inst.IsNonNull).?),
+ }
+}
+
+fn analyzeInstBreakpoint(self: *Module, scope: *Scope, inst: *zir.Inst.Breakpoint) InnerError!*Inst {
+ const b = try self.requireRuntimeBlock(scope, inst.base.src);
+ return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Breakpoint, Inst.Args(Inst.Breakpoint){});
+}
+
+fn analyzeInstRef(self: *Module, scope: *Scope, inst: *zir.Inst.Ref) InnerError!*Inst {
+ const decl = try self.resolveCompleteDecl(scope, inst.positionals.operand);
+ return self.analyzeDeclRef(scope, inst.base.src, decl);
+}
+
+fn analyzeInstDeclRef(self: *Module, scope: *Scope, inst: *zir.Inst.DeclRef) InnerError!*Inst {
+ const decl_name = try self.resolveConstString(scope, inst.positionals.name);
+ // This will need to get more fleshed out when there are proper structs & namespaces.
+ const zir_module = scope.namespace();
+ for (zir_module.contents.module.decls) |src_decl| {
+ if (mem.eql(u8, src_decl.name, decl_name)) {
+ const decl = try self.resolveCompleteDecl(scope, src_decl);
+ return self.analyzeDeclRef(scope, inst.base.src, decl);
+ }
+ }
+ return self.fail(scope, inst.positionals.name.src, "use of undeclared identifier '{}'", .{decl_name});
+}
+
+fn analyzeDeclRef(self: *Module, scope: *Scope, src: usize, decl: *Decl) InnerError!*Inst {
+ const decl_tv = try decl.typedValue();
+ const ty_payload = try scope.arena().create(Type.Payload.SingleConstPointer);
+ ty_payload.* = .{ .pointee_type = decl_tv.ty };
+ const val_payload = try scope.arena().create(Value.Payload.DeclRef);
+ val_payload.* = .{ .decl = decl };
+ return self.constInst(scope, src, .{
+ .ty = Type.initPayload(&ty_payload.base),
+ .val = Value.initPayload(&val_payload.base),
+ });
+}
+
+fn analyzeInstCall(self: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerError!*Inst {
+ const func = try self.resolveInst(scope, inst.positionals.func);
+ if (func.ty.zigTypeTag() != .Fn)
+ return self.fail(scope, inst.positionals.func.src, "type '{}' not a function", .{func.ty});
+
+ const cc = func.ty.fnCallingConvention();
+ if (cc == .Naked) {
+ // TODO add error note: declared here
+ return self.fail(
+ scope,
+ inst.positionals.func.src,
+ "unable to call function with naked calling convention",
+ .{},
+ );
+ }
+ const call_params_len = inst.positionals.args.len;
+ const fn_params_len = func.ty.fnParamLen();
+ if (func.ty.fnIsVarArgs()) {
+ if (call_params_len < fn_params_len) {
+ // TODO add error note: declared here
+ return self.fail(
+ scope,
+ inst.positionals.func.src,
+ "expected at least {} arguments, found {}",
+ .{ fn_params_len, call_params_len },
+ );
+ }
+ return self.fail(scope, inst.base.src, "TODO implement support for calling var args functions", .{});
+ } else if (fn_params_len != call_params_len) {
+ // TODO add error note: declared here
+ return self.fail(
+ scope,
+ inst.positionals.func.src,
+ "expected {} arguments, found {}",
+ .{ fn_params_len, call_params_len },
+ );
+ }
+
+ if (inst.kw_args.modifier == .compile_time) {
+ return self.fail(scope, inst.base.src, "TODO implement comptime function calls", .{});
+ }
+ if (inst.kw_args.modifier != .auto) {
+ return self.fail(scope, inst.base.src, "TODO implement call with modifier {}", .{inst.kw_args.modifier});
+ }
+
+ // TODO handle function calls of generic functions
+
+ const fn_param_types = try self.allocator.alloc(Type, fn_params_len);
+ defer self.allocator.free(fn_param_types);
+ func.ty.fnParamTypes(fn_param_types);
+
+ const casted_args = try scope.arena().alloc(*Inst, fn_params_len);
+ for (inst.positionals.args) |src_arg, i| {
+ const uncasted_arg = try self.resolveInst(scope, src_arg);
+ casted_args[i] = try self.coerce(scope, fn_param_types[i], uncasted_arg);
+ }
+
+ const b = try self.requireRuntimeBlock(scope, inst.base.src);
+ return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Call, Inst.Args(Inst.Call){
+ .func = func,
+ .args = casted_args,
+ });
+}
+
+fn analyzeInstFn(self: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError!*Inst {
+ const fn_type = try self.resolveType(scope, fn_inst.positionals.fn_type);
+ const new_func = try scope.arena().create(Fn);
+ new_func.* = .{
+ .fn_type = fn_type,
+ .analysis = .{ .queued = fn_inst },
+ };
+ const fn_payload = try scope.arena().create(Value.Payload.Function);
+ fn_payload.* = .{ .func = new_func };
+ return self.constInst(scope, fn_inst.base.src, .{
+ .ty = fn_type,
+ .val = Value.initPayload(&fn_payload.base),
+ });
+}
+
+fn analyzeInstFnType(self: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*Inst {
+ const return_type = try self.resolveType(scope, fntype.positionals.return_type);
+
+ if (return_type.zigTypeTag() == .NoReturn and
+ fntype.positionals.param_types.len == 0 and
+ fntype.kw_args.cc == .Unspecified)
+ {
+ return self.constType(scope, fntype.base.src, Type.initTag(.fn_noreturn_no_args));
+ }
+
+ if (return_type.zigTypeTag() == .NoReturn and
+ fntype.positionals.param_types.len == 0 and
+ fntype.kw_args.cc == .Naked)
+ {
+ return self.constType(scope, fntype.base.src, Type.initTag(.fn_naked_noreturn_no_args));
+ }
+
+ if (return_type.zigTypeTag() == .Void and
+ fntype.positionals.param_types.len == 0 and
+ fntype.kw_args.cc == .C)
+ {
+ return self.constType(scope, fntype.base.src, Type.initTag(.fn_ccc_void_no_args));
+ }
+
+ return self.fail(scope, fntype.base.src, "TODO implement fntype instruction more", .{});
+}
+
+fn analyzeInstPrimitive(self: *Module, scope: *Scope, primitive: *zir.Inst.Primitive) InnerError!*Inst {
+ return self.constType(scope, primitive.base.src, primitive.positionals.tag.toType());
+}
+
+fn analyzeInstAs(self: *Module, scope: *Scope, as: *zir.Inst.As) InnerError!*Inst {
+ const dest_type = try self.resolveType(scope, as.positionals.dest_type);
+ const new_inst = try self.resolveInst(scope, as.positionals.value);
+ return self.coerce(scope, dest_type, new_inst);
+}
+
+fn analyzeInstPtrToInt(self: *Module, scope: *Scope, ptrtoint: *zir.Inst.PtrToInt) InnerError!*Inst {
+ const ptr = try self.resolveInst(scope, ptrtoint.positionals.ptr);
+ if (ptr.ty.zigTypeTag() != .Pointer) {
+ return self.fail(scope, ptrtoint.positionals.ptr.src, "expected pointer, found '{}'", .{ptr.ty});
+ }
+ // TODO handle known-pointer-address
+ const b = try self.requireRuntimeBlock(scope, ptrtoint.base.src);
+ const ty = Type.initTag(.usize);
+ return self.addNewInstArgs(b, ptrtoint.base.src, ty, Inst.PtrToInt, Inst.Args(Inst.PtrToInt){ .ptr = ptr });
+}
+
+fn analyzeInstFieldPtr(self: *Module, scope: *Scope, fieldptr: *zir.Inst.FieldPtr) InnerError!*Inst {
+ const object_ptr = try self.resolveInst(scope, fieldptr.positionals.object_ptr);
+ const field_name = try self.resolveConstString(scope, fieldptr.positionals.field_name);
+
+ const elem_ty = switch (object_ptr.ty.zigTypeTag()) {
+ .Pointer => object_ptr.ty.elemType(),
+ else => return self.fail(scope, fieldptr.positionals.object_ptr.src, "expected pointer, found '{}'", .{object_ptr.ty}),
+ };
+ switch (elem_ty.zigTypeTag()) {
+ .Array => {
+ if (mem.eql(u8, field_name, "len")) {
+ const len_payload = try scope.arena().create(Value.Payload.Int_u64);
+ len_payload.* = .{ .int = elem_ty.arrayLen() };
+
+ const ref_payload = try scope.arena().create(Value.Payload.RefVal);
+ ref_payload.* = .{ .val = Value.initPayload(&len_payload.base) };
+
+ return self.constInst(scope, fieldptr.base.src, .{
+ .ty = Type.initTag(.single_const_pointer_to_comptime_int),
+ .val = Value.initPayload(&ref_payload.base),
+ });
+ } else {
+ return self.fail(
+ scope,
+ fieldptr.positionals.field_name.src,
+ "no member named '{}' in '{}'",
+ .{ field_name, elem_ty },
+ );
+ }
+ },
+ else => return self.fail(scope, fieldptr.base.src, "type '{}' does not support field access", .{elem_ty}),
+ }
+}
+
+fn analyzeInstIntCast(self: *Module, scope: *Scope, intcast: *zir.Inst.IntCast) InnerError!*Inst {
+ const dest_type = try self.resolveType(scope, intcast.positionals.dest_type);
+ const new_inst = try self.resolveInst(scope, intcast.positionals.value);
+
+ const dest_is_comptime_int = switch (dest_type.zigTypeTag()) {
+ .ComptimeInt => true,
+ .Int => false,
+ else => return self.fail(
+ scope,
+ intcast.positionals.dest_type.src,
+ "expected integer type, found '{}'",
+ .{
+ dest_type,
+ },
+ ),
+ };
+
+ switch (new_inst.ty.zigTypeTag()) {
+ .ComptimeInt, .Int => {},
+ else => return self.fail(
+ scope,
+ intcast.positionals.value.src,
+ "expected integer type, found '{}'",
+ .{new_inst.ty},
+ ),
+ }
+
+ if (dest_is_comptime_int or new_inst.value() != null) {
+ return self.coerce(scope, dest_type, new_inst);
+ }
+
+ return self.fail(scope, intcast.base.src, "TODO implement analyze widen or shorten int", .{});
+}
+
+fn analyzeInstBitCast(self: *Module, scope: *Scope, inst: *zir.Inst.BitCast) InnerError!*Inst {
+ const dest_type = try self.resolveType(scope, inst.positionals.dest_type);
+ const operand = try self.resolveInst(scope, inst.positionals.operand);
+ return self.bitcast(scope, dest_type, operand);
+}
+
+fn analyzeInstElemPtr(self: *Module, scope: *Scope, inst: *zir.Inst.ElemPtr) InnerError!*Inst {
+ const array_ptr = try self.resolveInst(scope, inst.positionals.array_ptr);
+ const uncasted_index = try self.resolveInst(scope, inst.positionals.index);
+ const elem_index = try self.coerce(scope, Type.initTag(.usize), uncasted_index);
+
+ if (array_ptr.ty.isSinglePointer() and array_ptr.ty.elemType().zigTypeTag() == .Array) {
+ if (array_ptr.value()) |array_ptr_val| {
+ if (elem_index.value()) |index_val| {
+ // Both array pointer and index are compile-time known.
+ const index_u64 = index_val.toUnsignedInt();
+ // @intCast here because it would have been impossible to construct a value that
+ // required a larger index.
+ const elem_ptr = try array_ptr_val.elemPtr(scope.arena(), @intCast(usize, index_u64));
+
+ const type_payload = try scope.arena().create(Type.Payload.SingleConstPointer);
+ type_payload.* = .{ .pointee_type = array_ptr.ty.elemType().elemType() };
+
+ return self.constInst(scope, inst.base.src, .{
+ .ty = Type.initPayload(&type_payload.base),
+ .val = elem_ptr,
+ });
+ }
+ }
+ }
+
+ return self.fail(scope, inst.base.src, "TODO implement more analyze elemptr", .{});
+}
+
+fn analyzeInstAdd(self: *Module, scope: *Scope, inst: *zir.Inst.Add) InnerError!*Inst {
+ const lhs = try self.resolveInst(scope, inst.positionals.lhs);
+ const rhs = try self.resolveInst(scope, inst.positionals.rhs);
+
+ if (lhs.ty.zigTypeTag() == .Int and rhs.ty.zigTypeTag() == .Int) {
+ if (lhs.value()) |lhs_val| {
+ if (rhs.value()) |rhs_val| {
+ // TODO is this a performance issue? maybe we should try the operation without
+ // resorting to BigInt first.
+ var lhs_space: Value.BigIntSpace = undefined;
+ var rhs_space: Value.BigIntSpace = undefined;
+ const lhs_bigint = lhs_val.toBigInt(&lhs_space);
+ const rhs_bigint = rhs_val.toBigInt(&rhs_space);
+ const limbs = try scope.arena().alloc(
+ std.math.big.Limb,
+ std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
+ );
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ result_bigint.add(lhs_bigint, rhs_bigint);
+ const result_limbs = result_bigint.limbs[0..result_bigint.len];
+
+ if (!lhs.ty.eql(rhs.ty)) {
+ return self.fail(scope, inst.base.src, "TODO implement peer type resolution", .{});
+ }
+
+ const val_payload = if (result_bigint.positive) blk: {
+ const val_payload = try scope.arena().create(Value.Payload.IntBigPositive);
+ val_payload.* = .{ .limbs = result_limbs };
+ break :blk &val_payload.base;
+ } else blk: {
+ const val_payload = try scope.arena().create(Value.Payload.IntBigNegative);
+ val_payload.* = .{ .limbs = result_limbs };
+ break :blk &val_payload.base;
+ };
+
+ return self.constInst(scope, inst.base.src, .{
+ .ty = lhs.ty,
+ .val = Value.initPayload(val_payload),
+ });
+ }
+ }
+ }
+
+ return self.fail(scope, inst.base.src, "TODO implement more analyze add", .{});
+}
+
+fn analyzeInstDeref(self: *Module, scope: *Scope, deref: *zir.Inst.Deref) InnerError!*Inst {
+ const ptr = try self.resolveInst(scope, deref.positionals.ptr);
+ return self.analyzeDeref(scope, deref.base.src, ptr, deref.positionals.ptr.src);
+}
+
+fn analyzeDeref(self: *Module, scope: *Scope, src: usize, ptr: *Inst, ptr_src: usize) InnerError!*Inst {
+ const elem_ty = switch (ptr.ty.zigTypeTag()) {
+ .Pointer => ptr.ty.elemType(),
+ else => return self.fail(scope, ptr_src, "expected pointer, found '{}'", .{ptr.ty}),
+ };
+ if (ptr.value()) |val| {
+ return self.constInst(scope, src, .{
+ .ty = elem_ty,
+ .val = try val.pointerDeref(scope.arena()),
+ });
+ }
+
+ return self.fail(scope, src, "TODO implement runtime deref", .{});
+}
+
+fn analyzeInstAsm(self: *Module, scope: *Scope, assembly: *zir.Inst.Asm) InnerError!*Inst {
+ const return_type = try self.resolveType(scope, assembly.positionals.return_type);
+ const asm_source = try self.resolveConstString(scope, assembly.positionals.asm_source);
+ const output = if (assembly.kw_args.output) |o| try self.resolveConstString(scope, o) else null;
+
+ const inputs = try scope.arena().alloc([]const u8, assembly.kw_args.inputs.len);
+ const clobbers = try scope.arena().alloc([]const u8, assembly.kw_args.clobbers.len);
+ const args = try scope.arena().alloc(*Inst, assembly.kw_args.args.len);
+
+ for (inputs) |*elem, i| {
+ elem.* = try self.resolveConstString(scope, assembly.kw_args.inputs[i]);
+ }
+ for (clobbers) |*elem, i| {
+ elem.* = try self.resolveConstString(scope, assembly.kw_args.clobbers[i]);
+ }
+ for (args) |*elem, i| {
+ const arg = try self.resolveInst(scope, assembly.kw_args.args[i]);
+ elem.* = try self.coerce(scope, Type.initTag(.usize), arg);
+ }
+
+ const b = try self.requireRuntimeBlock(scope, assembly.base.src);
+ return self.addNewInstArgs(b, assembly.base.src, return_type, Inst.Assembly, Inst.Args(Inst.Assembly){
+ .asm_source = asm_source,
+ .is_volatile = assembly.kw_args.@"volatile",
+ .output = output,
+ .inputs = inputs,
+ .clobbers = clobbers,
+ .args = args,
+ });
+}
+
+fn analyzeInstCmp(self: *Module, scope: *Scope, inst: *zir.Inst.Cmp) InnerError!*Inst {
+ const lhs = try self.resolveInst(scope, inst.positionals.lhs);
+ const rhs = try self.resolveInst(scope, inst.positionals.rhs);
+ const op = inst.positionals.op;
+
+ const is_equality_cmp = switch (op) {
+ .eq, .neq => true,
+ else => false,
+ };
+ const lhs_ty_tag = lhs.ty.zigTypeTag();
+ const rhs_ty_tag = rhs.ty.zigTypeTag();
+ if (is_equality_cmp and lhs_ty_tag == .Null and rhs_ty_tag == .Null) {
+ // null == null, null != null
+ return self.constBool(scope, inst.base.src, op == .eq);
+ } else if (is_equality_cmp and
+ ((lhs_ty_tag == .Null and rhs_ty_tag == .Optional) or
+ rhs_ty_tag == .Null and lhs_ty_tag == .Optional))
+ {
+ // comparing null with optionals
+ const opt_operand = if (lhs_ty_tag == .Optional) lhs else rhs;
+ if (opt_operand.value()) |opt_val| {
+ const is_null = opt_val.isNull();
+ return self.constBool(scope, inst.base.src, if (op == .eq) is_null else !is_null);
+ }
+ const b = try self.requireRuntimeBlock(scope, inst.base.src);
+ switch (op) {
+ .eq => return self.addNewInstArgs(
+ b,
+ inst.base.src,
+ Type.initTag(.bool),
+ Inst.IsNull,
+ Inst.Args(Inst.IsNull){ .operand = opt_operand },
+ ),
+ .neq => return self.addNewInstArgs(
+ b,
+ inst.base.src,
+ Type.initTag(.bool),
+ Inst.IsNonNull,
+ Inst.Args(Inst.IsNonNull){ .operand = opt_operand },
+ ),
+ else => unreachable,
+ }
+ } else if (is_equality_cmp and
+ ((lhs_ty_tag == .Null and rhs.ty.isCPtr()) or (rhs_ty_tag == .Null and lhs.ty.isCPtr())))
+ {
+ return self.fail(scope, inst.base.src, "TODO implement C pointer cmp", .{});
+ } else if (lhs_ty_tag == .Null or rhs_ty_tag == .Null) {
+ const non_null_type = if (lhs_ty_tag == .Null) rhs.ty else lhs.ty;
+ return self.fail(scope, inst.base.src, "comparison of '{}' with null", .{non_null_type});
+ } else if (is_equality_cmp and
+ ((lhs_ty_tag == .EnumLiteral and rhs_ty_tag == .Union) or
+ (rhs_ty_tag == .EnumLiteral and lhs_ty_tag == .Union)))
+ {
+ return self.fail(scope, inst.base.src, "TODO implement equality comparison between a union's tag value and an enum literal", .{});
+ } else if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {
+ if (!is_equality_cmp) {
+ return self.fail(scope, inst.base.src, "{} operator not allowed for errors", .{@tagName(op)});
+ }
+ return self.fail(scope, inst.base.src, "TODO implement equality comparison between errors", .{});
+ } else if (lhs.ty.isNumeric() and rhs.ty.isNumeric()) {
+ // This operation allows any combination of integer and float types, regardless of the
+ // signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for
+ // numeric types.
+ return self.cmpNumeric(scope, inst.base.src, lhs, rhs, op);
+ }
+ return self.fail(scope, inst.base.src, "TODO implement more cmp analysis", .{});
+}
+
+fn analyzeInstIsNull(self: *Module, scope: *Scope, inst: *zir.Inst.IsNull) InnerError!*Inst {
+ const operand = try self.resolveInst(scope, inst.positionals.operand);
+ return self.analyzeIsNull(scope, inst.base.src, operand, true);
+}
+
+fn analyzeInstIsNonNull(self: *Module, scope: *Scope, inst: *zir.Inst.IsNonNull) InnerError!*Inst {
+ const operand = try self.resolveInst(scope, inst.positionals.operand);
+ return self.analyzeIsNull(scope, inst.base.src, operand, false);
+}
+
+fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *zir.Inst.CondBr) InnerError!*Inst {
+ const uncasted_cond = try self.resolveInst(scope, inst.positionals.condition);
+ const cond = try self.coerce(scope, Type.initTag(.bool), uncasted_cond);
+
+ if (try self.resolveDefinedValue(scope, cond)) |cond_val| {
+ const body = if (cond_val.toBool()) &inst.positionals.true_body else &inst.positionals.false_body;
+ try self.analyzeBody(scope, body.*);
+ return self.constVoid(scope, inst.base.src);
+ }
+
+ const parent_block = try self.requireRuntimeBlock(scope, inst.base.src);
+
+ var true_block: Scope.Block = .{
+ .func = parent_block.func,
+ .decl = parent_block.decl,
+ .instructions = .{},
+ .arena = parent_block.arena,
+ };
+ defer true_block.instructions.deinit(self.allocator);
+ try self.analyzeBody(&true_block.base, inst.positionals.true_body);
+
+ var false_block: Scope.Block = .{
+ .func = parent_block.func,
+ .decl = parent_block.decl,
+ .instructions = .{},
+ .arena = parent_block.arena,
+ };
+ defer false_block.instructions.deinit(self.allocator);
+ try self.analyzeBody(&false_block.base, inst.positionals.false_body);
+
+ return self.addNewInstArgs(parent_block, inst.base.src, Type.initTag(.void), Inst.CondBr, Inst.Args(Inst.CondBr){
+ .condition = cond,
+ .true_body = .{ .instructions = try scope.arena().dupe(*Inst, true_block.instructions.items) },
+ .false_body = .{ .instructions = try scope.arena().dupe(*Inst, false_block.instructions.items) },
+ });
+}
+
+fn wantSafety(self: *Module, scope: *Scope) bool {
+ return switch (self.optimize_mode) {
+ .Debug => true,
+ .ReleaseSafe => true,
+ .ReleaseFast => false,
+ .ReleaseSmall => false,
+ };
+}
+
+fn analyzeInstUnreachable(self: *Module, scope: *Scope, unreach: *zir.Inst.Unreachable) InnerError!*Inst {
+ const b = try self.requireRuntimeBlock(scope, unreach.base.src);
+ if (self.wantSafety(scope)) {
+ // TODO Once we have a panic function to call, call it here instead of this.
+ _ = try self.addNewInstArgs(b, unreach.base.src, Type.initTag(.void), Inst.Breakpoint, {});
+ }
+ return self.addNewInstArgs(b, unreach.base.src, Type.initTag(.noreturn), Inst.Unreach, {});
+}
+
+fn analyzeInstRet(self: *Module, scope: *Scope, inst: *zir.Inst.Return) InnerError!*Inst {
+ const b = try self.requireRuntimeBlock(scope, inst.base.src);
+ return self.addNewInstArgs(b, inst.base.src, Type.initTag(.noreturn), Inst.Ret, {});
+}
+
+fn analyzeBody(self: *Module, scope: *Scope, body: zir.Module.Body) !void {
+ if (scope.cast(Scope.Block)) |b| {
+ const analysis = b.func.analysis.in_progress;
+ analysis.needed_inst_capacity += body.instructions.len;
+ try analysis.inst_table.ensureCapacity(analysis.needed_inst_capacity);
+ for (body.instructions) |src_inst| {
+ const new_inst = try self.analyzeInst(scope, src_inst);
+ analysis.inst_table.putAssumeCapacityNoClobber(src_inst, new_inst);
+ }
+ } else {
+ for (body.instructions) |src_inst| {
+ _ = try self.analyzeInst(scope, src_inst);
+ }
+ }
+}
+
+fn analyzeIsNull(
+ self: *Module,
+ scope: *Scope,
+ src: usize,
+ operand: *Inst,
+ invert_logic: bool,
+) InnerError!*Inst {
+ return self.fail(scope, src, "TODO implement analysis of isnull and isnotnull", .{});
+}
+
+/// Asserts that lhs and rhs types are both numeric.
+fn cmpNumeric(
+ self: *Module,
+ scope: *Scope,
+ src: usize,
+ lhs: *Inst,
+ rhs: *Inst,
+ op: std.math.CompareOperator,
+) !*Inst {
+ assert(lhs.ty.isNumeric());
+ assert(rhs.ty.isNumeric());
+
+ const lhs_ty_tag = lhs.ty.zigTypeTag();
+ const rhs_ty_tag = rhs.ty.zigTypeTag();
+
+ if (lhs_ty_tag == .Vector and rhs_ty_tag == .Vector) {
+ if (lhs.ty.arrayLen() != rhs.ty.arrayLen()) {
+ return self.fail(scope, src, "vector length mismatch: {} and {}", .{
+ lhs.ty.arrayLen(),
+ rhs.ty.arrayLen(),
+ });
+ }
+ return self.fail(scope, src, "TODO implement support for vectors in cmpNumeric", .{});
+ } else if (lhs_ty_tag == .Vector or rhs_ty_tag == .Vector) {
+ return self.fail(scope, src, "mixed scalar and vector operands to comparison operator: '{}' and '{}'", .{
+ lhs.ty,
+ rhs.ty,
+ });
+ }
+
+ if (lhs.value()) |lhs_val| {
+ if (rhs.value()) |rhs_val| {
+ return self.constBool(scope, src, Value.compare(lhs_val, op, rhs_val));
+ }
+ }
+
+ // TODO handle comparisons against lazy zero values
+ // Some values can be compared against zero without being runtime known or without forcing
+ // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to
+ // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout
+ // of this function if we don't need to.
+
+ // It must be a runtime comparison.
+ const b = try self.requireRuntimeBlock(scope, src);
+ // For floats, emit a float comparison instruction.
+ const lhs_is_float = switch (lhs_ty_tag) {
+ .Float, .ComptimeFloat => true,
+ else => false,
+ };
+ const rhs_is_float = switch (rhs_ty_tag) {
+ .Float, .ComptimeFloat => true,
+ else => false,
+ };
+ if (lhs_is_float and rhs_is_float) {
+ // Implicit cast the smaller one to the larger one.
+ const dest_type = x: {
+ if (lhs_ty_tag == .ComptimeFloat) {
+ break :x rhs.ty;
+ } else if (rhs_ty_tag == .ComptimeFloat) {
+ break :x lhs.ty;
+ }
+ if (lhs.ty.floatBits(self.target()) >= rhs.ty.floatBits(self.target())) {
+ break :x lhs.ty;
+ } else {
+ break :x rhs.ty;
+ }
+ };
+ const casted_lhs = try self.coerce(scope, dest_type, lhs);
+ const casted_rhs = try self.coerce(scope, dest_type, rhs);
+ return self.addNewInstArgs(b, src, dest_type, Inst.Cmp, Inst.Args(Inst.Cmp){
+ .lhs = casted_lhs,
+ .rhs = casted_rhs,
+ .op = op,
+ });
+ }
+ // For mixed unsigned integer sizes, implicit cast both operands to the larger integer.
+ // For mixed signed and unsigned integers, implicit cast both operands to a signed
+ // integer with + 1 bit.
+ // For mixed floats and integers, extract the integer part from the float, cast that to
+ // a signed integer with mantissa bits + 1, and if there was any non-integral part of the float,
+ // add/subtract 1.
+ const lhs_is_signed = if (lhs.value()) |lhs_val|
+ lhs_val.compareWithZero(.lt)
+ else
+ (lhs.ty.isFloat() or lhs.ty.isSignedInt());
+ const rhs_is_signed = if (rhs.value()) |rhs_val|
+ rhs_val.compareWithZero(.lt)
+ else
+ (rhs.ty.isFloat() or rhs.ty.isSignedInt());
+ const dest_int_is_signed = lhs_is_signed or rhs_is_signed;
+
+ var dest_float_type: ?Type = null;
+
+ var lhs_bits: usize = undefined;
+ if (lhs.value()) |lhs_val| {
+ if (lhs_val.isUndef())
+ return self.constUndef(scope, src, Type.initTag(.bool));
+ const is_unsigned = if (lhs_is_float) x: {
+ var bigint_space: Value.BigIntSpace = undefined;
+ var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
+ defer bigint.deinit();
+ const zcmp = lhs_val.orderAgainstZero();
+ if (lhs_val.floatHasFraction()) {
+ switch (op) {
+ .eq => return self.constBool(scope, src, false),
+ .neq => return self.constBool(scope, src, true),
+ else => {},
+ }
+ if (zcmp == .lt) {
+ try bigint.addScalar(bigint.toConst(), -1);
+ } else {
+ try bigint.addScalar(bigint.toConst(), 1);
+ }
+ }
+ lhs_bits = bigint.toConst().bitCountTwosComp();
+ break :x (zcmp != .lt);
+ } else x: {
+ lhs_bits = lhs_val.intBitCountTwosComp();
+ break :x (lhs_val.orderAgainstZero() != .lt);
+ };
+ lhs_bits += @boolToInt(is_unsigned and dest_int_is_signed);
+ } else if (lhs_is_float) {
+ dest_float_type = lhs.ty;
+ } else {
+ const int_info = lhs.ty.intInfo(self.target());
+ lhs_bits = int_info.bits + @boolToInt(!int_info.signed and dest_int_is_signed);
+ }
+
+ var rhs_bits: usize = undefined;
+ if (rhs.value()) |rhs_val| {
+ if (rhs_val.isUndef())
+ return self.constUndef(scope, src, Type.initTag(.bool));
+ const is_unsigned = if (rhs_is_float) x: {
+ var bigint_space: Value.BigIntSpace = undefined;
+ var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
+ defer bigint.deinit();
+ const zcmp = rhs_val.orderAgainstZero();
+ if (rhs_val.floatHasFraction()) {
+ switch (op) {
+ .eq => return self.constBool(scope, src, false),
+ .neq => return self.constBool(scope, src, true),
+ else => {},
+ }
+ if (zcmp == .lt) {
+ try bigint.addScalar(bigint.toConst(), -1);
+ } else {
+ try bigint.addScalar(bigint.toConst(), 1);
+ }
+ }
+ rhs_bits = bigint.toConst().bitCountTwosComp();
+ break :x (zcmp != .lt);
+ } else x: {
+ rhs_bits = rhs_val.intBitCountTwosComp();
+ break :x (rhs_val.orderAgainstZero() != .lt);
+ };
+ rhs_bits += @boolToInt(is_unsigned and dest_int_is_signed);
+ } else if (rhs_is_float) {
+ dest_float_type = rhs.ty;
+ } else {
+ const int_info = rhs.ty.intInfo(self.target());
+ rhs_bits = int_info.bits + @boolToInt(!int_info.signed and dest_int_is_signed);
+ }
+
+ const dest_type = if (dest_float_type) |ft| ft else blk: {
+ const max_bits = std.math.max(lhs_bits, rhs_bits);
+ const casted_bits = std.math.cast(u16, max_bits) catch |err| switch (err) {
+ error.Overflow => return self.fail(scope, src, "{} exceeds maximum integer bit count", .{max_bits}),
+ };
+ break :blk try self.makeIntType(scope, dest_int_is_signed, casted_bits);
+ };
+ const casted_lhs = try self.coerce(scope, dest_type, lhs);
+ const casted_rhs = try self.coerce(scope, dest_type, lhs);
+
+ return self.addNewInstArgs(b, src, dest_type, Inst.Cmp, Inst.Args(Inst.Cmp){
+ .lhs = casted_lhs,
+ .rhs = casted_rhs,
+ .op = op,
+ });
+}
+
+fn makeIntType(self: *Module, scope: *Scope, signed: bool, bits: u16) !Type {
+ if (signed) {
+ const int_payload = try scope.arena().create(Type.Payload.IntSigned);
+ int_payload.* = .{ .bits = bits };
+ return Type.initPayload(&int_payload.base);
+ } else {
+ const int_payload = try scope.arena().create(Type.Payload.IntUnsigned);
+ int_payload.* = .{ .bits = bits };
+ return Type.initPayload(&int_payload.base);
+ }
+}
+
+fn coerce(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
+ // If the types are the same, we can return the operand.
+ if (dest_type.eql(inst.ty))
+ return inst;
+
+ const in_memory_result = coerceInMemoryAllowed(dest_type, inst.ty);
+ if (in_memory_result == .ok) {
+ return self.bitcast(scope, dest_type, inst);
+ }
+
+ // *[N]T to []T
+ if (inst.ty.isSinglePointer() and dest_type.isSlice() and
+ (!inst.ty.pointerIsConst() or dest_type.pointerIsConst()))
+ {
+ const array_type = inst.ty.elemType();
+ const dst_elem_type = dest_type.elemType();
+ if (array_type.zigTypeTag() == .Array and
+ coerceInMemoryAllowed(dst_elem_type, array_type.elemType()) == .ok)
+ {
+ return self.coerceArrayPtrToSlice(scope, dest_type, inst);
+ }
+ }
+
+ // comptime_int to fixed-width integer
+ if (inst.ty.zigTypeTag() == .ComptimeInt and dest_type.zigTypeTag() == .Int) {
+ // The representation is already correct; we only need to make sure it fits in the destination type.
+ const val = inst.value().?; // comptime_int always has comptime known value
+ if (!val.intFitsInType(dest_type, self.target())) {
+ return self.fail(scope, inst.src, "type {} cannot represent integer value {}", .{ inst.ty, val });
+ }
+ return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
+ }
+
+ // integer widening
+ if (inst.ty.zigTypeTag() == .Int and dest_type.zigTypeTag() == .Int) {
+ const src_info = inst.ty.intInfo(self.target());
+ const dst_info = dest_type.intInfo(self.target());
+ if (src_info.signed == dst_info.signed and dst_info.bits >= src_info.bits) {
+ if (inst.value()) |val| {
+ return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
+ } else {
+ return self.fail(scope, inst.src, "TODO implement runtime integer widening", .{});
+ }
+ } else {
+ return self.fail(scope, inst.src, "TODO implement more int widening {} to {}", .{ inst.ty, dest_type });
+ }
+ }
+
+ return self.fail(scope, inst.src, "TODO implement type coercion from {} to {}", .{ inst.ty, dest_type });
+}
+
+fn bitcast(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
+ if (inst.value()) |val| {
+ // Keep the comptime Value representation; take the new type.
+ return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
+ }
+ // TODO validate the type size and other compile errors
+ const b = try self.requireRuntimeBlock(scope, inst.src);
+ return self.addNewInstArgs(b, inst.src, dest_type, Inst.BitCast, Inst.Args(Inst.BitCast){ .operand = inst });
+}
+
+fn coerceArrayPtrToSlice(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
+ if (inst.value()) |val| {
+ // The comptime Value representation is compatible with both types.
+ return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
+ }
+ return self.fail(scope, inst.src, "TODO implement coerceArrayPtrToSlice runtime instruction", .{});
+}
+
+fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: var) InnerError {
+ @setCold(true);
+ try self.failed_decls.ensureCapacity(self.failed_decls.size + 1);
+ try self.failed_files.ensureCapacity(self.failed_files.size + 1);
+ const err_msg = try ErrorMsg.create(self.allocator, src, format, args);
+ switch (scope.tag) {
+ .decl => {
+ const decl = scope.cast(Scope.DeclAnalysis).?.decl;
+ switch (decl.analysis) {
+ .initial_in_progress => decl.analysis = .initial_sema_failure,
+ .repeat_in_progress => decl.analysis = .repeat_sema_failure,
+ else => unreachable,
+ }
+ self.failed_decls.putAssumeCapacityNoClobber(decl, err_msg);
+ },
+ .block => {
+ const block = scope.cast(Scope.Block).?;
+ block.func.analysis = .sema_failure;
+ self.failed_decls.putAssumeCapacityNoClobber(block.decl, err_msg);
+ },
+ .zir_module => {
+ const zir_module = scope.cast(Scope.ZIRModule).?;
+ zir_module.status = .loaded_sema_failure;
+ self.failed_files.putAssumeCapacityNoClobber(zir_module, err_msg);
+ },
+ }
+ return error.AnalysisFail;
+}
+
+const InMemoryCoercionResult = enum {
+ ok,
+ no_match,
+};
+
+fn coerceInMemoryAllowed(dest_type: Type, src_type: Type) InMemoryCoercionResult {
+ if (dest_type.eql(src_type))
+ return .ok;
+
+ // TODO: implement more of this function
+
+ return .no_match;
+}
+
+pub const ErrorMsg = struct {
+ byte_offset: usize,
+ msg: []const u8,
+
+ pub fn create(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !*ErrorMsg {
+ const self = try allocator.create(ErrorMsg);
+ errdefer allocator.destroy(self);
+ self.* = try init(allocator, byte_offset, format, args);
+ return self;
+ }
+
+ /// Assumes the ErrorMsg struct and msg were both allocated with allocator.
+ pub fn destroy(self: *ErrorMsg, allocator: *Allocator) void {
+ self.deinit(allocator);
+ allocator.destroy(self);
+ }
+
+ pub fn init(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !ErrorMsg {
+ return ErrorMsg{
+ .byte_offset = byte_offset,
+ .msg = try std.fmt.allocPrint(allocator, format, args),
+ };
+ }
+
+ pub fn deinit(self: *ErrorMsg, allocator: *Allocator) void {
+ allocator.free(self.msg);
+ self.* = undefined;
+ }
+};
diff --git a/src-self-hosted/codegen.zig b/src-self-hosted/codegen.zig
@@ -6,6 +6,8 @@ const Type = @import("type.zig").Type;
const Value = @import("value.zig").Value;
const TypedValue = @import("TypedValue.zig");
const link = @import("link.zig");
+const Module = @import("Module.zig");
+const ErrorMsg = Module.ErrorMsg;
const Target = std.Target;
const Allocator = mem.Allocator;
@@ -14,7 +16,7 @@ pub const Result = union(enum) {
appended: void,
/// The value is available externally, `code` is unused.
externally_managed: []const u8,
- fail: *ir.ErrorMsg,
+ fail: *Module.ErrorMsg,
};
pub fn generateSymbol(
@@ -77,7 +79,7 @@ pub fn generateSymbol(
}
}
return Result{
- .fail = try ir.ErrorMsg.create(
+ .fail = try ErrorMsg.create(
bin_file.allocator,
src,
"TODO implement generateSymbol for more kinds of arrays",
@@ -107,7 +109,7 @@ pub fn generateSymbol(
return Result{ .appended = {} };
}
return Result{
- .fail = try ir.ErrorMsg.create(
+ .fail = try ErrorMsg.create(
bin_file.allocator,
src,
"TODO implement generateSymbol for pointer {}",
@@ -123,7 +125,7 @@ pub fn generateSymbol(
return Result{ .appended = {} };
}
return Result{
- .fail = try ir.ErrorMsg.create(
+ .fail = try ErrorMsg.create(
bin_file.allocator,
src,
"TODO implement generateSymbol for int type '{}'",
@@ -133,7 +135,7 @@ pub fn generateSymbol(
},
else => |t| {
return Result{
- .fail = try ir.ErrorMsg.create(
+ .fail = try ErrorMsg.create(
bin_file.allocator,
src,
"TODO implement generateSymbol for type '{}'",
@@ -147,10 +149,10 @@ pub fn generateSymbol(
const Function = struct {
bin_file: *link.ElfFile,
target: *const std.Target,
- mod_fn: *const ir.Module.Fn,
+ mod_fn: *const Module.Fn,
code: *std.ArrayList(u8),
inst_table: std.AutoHashMap(*ir.Inst, MCValue),
- err_msg: ?*ir.ErrorMsg,
+ err_msg: ?*ErrorMsg,
const MCValue = union(enum) {
none,
@@ -570,7 +572,7 @@ const Function = struct {
fn fail(self: *Function, src: usize, comptime format: []const u8, args: var) error{ CodegenFail, OutOfMemory } {
@setCold(true);
assert(self.err_msg == null);
- self.err_msg = try ir.ErrorMsg.create(self.code.allocator, src, format, args);
+ self.err_msg = try ErrorMsg.create(self.code.allocator, src, format, args);
return error.CodegenFail;
}
};
diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig
@@ -1,20 +1,9 @@
const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const ArrayListUnmanaged = std.ArrayListUnmanaged;
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
-const TypedValue = @import("TypedValue.zig");
-const assert = std.debug.assert;
-const BigIntConst = std.math.big.int.Const;
-const BigIntMutable = std.math.big.int.Mutable;
-const Target = std.Target;
-const Package = @import("Package.zig");
-const link = @import("link.zig");
+const Module = @import("Module.zig");
-pub const text = @import("ir/text.zig");
-
-/// These are in-memory, analyzed instructions. See `text.Inst` for the representation
+/// These are in-memory, analyzed instructions. See `zir.Inst` for the representation
/// of instructions that correspond to the ZIR text format.
/// This struct owns the `Value` and `Type` memory. When the struct is deallocated,
/// so are the `Value` and `Type`. The value of a constant must be copied into
@@ -166,2006 +155,3 @@ pub const Inst = struct {
args: void,
};
};
-
-pub const Module = struct {
- /// General-purpose allocator.
- allocator: *Allocator,
- /// Module owns this resource.
- root_pkg: *Package,
- /// Module owns this resource.
- root_scope: *Scope.ZIRModule,
- /// Pointer to externally managed resource.
- bin_file: *link.ElfFile,
- /// It's rare for a decl to be exported, so we save memory by having a sparse map of
- /// Decl pointers to details about them being exported.
- /// The Export memory is owned by the `export_owners` table; the slice itself is owned by this table.
- decl_exports: std.AutoHashMap(*Decl, []*Export),
- /// This models the Decls that perform exports, so that `decl_exports` can be updated when a Decl
- /// is modified. Note that the key of this table is not the Decl being exported, but the Decl that
- /// is performing the export of another Decl.
- /// This table owns the Export memory.
- export_owners: std.AutoHashMap(*Decl, []*Export),
- /// Maps fully qualified namespaced names to the Decl struct for them.
- decl_table: std.AutoHashMap(Decl.Hash, *Decl),
-
- optimize_mode: std.builtin.Mode,
- link_error_flags: link.ElfFile.ErrorFlags = link.ElfFile.ErrorFlags{},
-
- work_queue: std.fifo.LinearFifo(WorkItem, .Dynamic),
-
- /// We optimize memory usage for a compilation with no compile errors by storing the
- /// error messages and mapping outside of `Decl`.
- /// The ErrorMsg memory is owned by the decl, using Module's allocator.
- /// Note that a Decl can succeed but the Fn it represents can fail. In this case,
- /// a Decl can have a failed_decls entry but have analysis status of success.
- failed_decls: std.AutoHashMap(*Decl, *ErrorMsg),
- /// Using a map here for consistency with the other fields here.
- /// The ErrorMsg memory is owned by the `Scope.ZIRModule`, using Module's allocator.
- failed_files: std.AutoHashMap(*Scope.ZIRModule, *ErrorMsg),
- /// Using a map here for consistency with the other fields here.
- /// The ErrorMsg memory is owned by the `Export`, using Module's allocator.
- failed_exports: std.AutoHashMap(*Export, *ErrorMsg),
-
- pub const WorkItem = union(enum) {
- /// Write the machine code for a Decl to the output file.
- codegen_decl: *Decl,
- };
-
- pub const Export = struct {
- options: std.builtin.ExportOptions,
- /// Byte offset into the file that contains the export directive.
- src: usize,
- /// Represents the position of the export, if any, in the output file.
- link: link.ElfFile.Export,
- /// The Decl that performs the export. Note that this is *not* the Decl being exported.
- owner_decl: *Decl,
- status: enum {
- in_progress,
- failed,
- /// Indicates that the failure was due to a temporary issue, such as an I/O error
- /// when writing to the output file. Retrying the export may succeed.
- failed_retryable,
- complete,
- },
- };
-
- pub const Decl = struct {
- /// This name is relative to the containing namespace of the decl. It uses a null-termination
- /// to save bytes, since there can be a lot of decls in a compilation. The null byte is not allowed
- /// in symbol names, because executable file formats use null-terminated strings for symbol names.
- /// All Decls have names, even values that are not bound to a zig namespace. This is necessary for
- /// mapping them to an address in the output file.
- /// Memory owned by this decl, using Module's allocator.
- name: [*:0]const u8,
- /// The direct parent container of the Decl. This field will need to get more fleshed out when
- /// self-hosted supports proper struct types and Zig AST => ZIR.
- /// Reference to externally owned memory.
- scope: *Scope.ZIRModule,
- /// Byte offset into the source file that contains this declaration.
- /// This is the base offset that src offsets within this Decl are relative to.
- src: usize,
- /// The most recent value of the Decl after a successful semantic analysis.
- /// The tag for this union is determined by the tag value of the analysis field.
- typed_value: union {
- never_succeeded: void,
- most_recent: TypedValue.Managed,
- },
- /// Represents the "shallow" analysis status. For example, for decls that are functions,
- /// the function type is analyzed with this set to `in_progress`, however, the semantic
- /// analysis of the function body is performed with this value set to `success`. Functions
- /// have their own analysis status field.
- analysis: enum {
- initial_in_progress,
- /// This Decl might be OK but it depends on another one which did not successfully complete
- /// semantic analysis. This Decl never had a value computed.
- initial_dependency_failure,
- /// Semantic analysis failure. This Decl never had a value computed.
- /// There will be a corresponding ErrorMsg in Module.failed_decls.
- initial_sema_failure,
- /// In this case the `typed_value.most_recent` can still be accessed.
- /// There will be a corresponding ErrorMsg in Module.failed_decls.
- codegen_failure,
- /// In this case the `typed_value.most_recent` can still be accessed.
- /// There will be a corresponding ErrorMsg in Module.failed_decls.
- /// This indicates the failure was something like running out of disk space,
- /// and attempting codegen again may succeed.
- codegen_failure_retryable,
- /// This Decl might be OK but it depends on another one which did not successfully complete
- /// semantic analysis. There is a most recent value available.
- repeat_dependency_failure,
- /// Semantic anlaysis failure, but the `typed_value.most_recent` can be accessed.
- /// There will be a corresponding ErrorMsg in Module.failed_decls.
- repeat_sema_failure,
- /// Completed successfully before; the `typed_value.most_recent` can be accessed, and
- /// new semantic analysis is in progress.
- repeat_in_progress,
- /// Everything is done and updated.
- complete,
- },
-
- /// Represents the position of the code in the output file.
- /// This is populated regardless of semantic analysis and code generation.
- link: link.ElfFile.Decl = link.ElfFile.Decl.empty,
-
- /// The shallow set of other decls whose typed_value could possibly change if this Decl's
- /// typed_value is modified.
- /// TODO look into using a lightweight map/set data structure rather than a linear array.
- dependants: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
-
- contents_hash: Hash,
-
- pub fn destroy(self: *Decl, allocator: *Allocator) void {
- allocator.free(mem.spanZ(self.name));
- if (self.typedValueManaged()) |tvm| {
- tvm.deinit(allocator);
- }
- allocator.destroy(self);
- }
-
- pub const Hash = [16]u8;
-
- /// If the name is small enough, it is used directly as the hash.
- /// If it is long, blake3 hash is computed.
- pub fn hashSimpleName(name: []const u8) Hash {
- var out: Hash = undefined;
- if (name.len <= Hash.len) {
- mem.copy(u8, &out, name);
- mem.set(u8, out[name.len..], 0);
- } else {
- std.crypto.Blake3.hash(name, &out);
- }
- return out;
- }
-
- /// Must generate unique bytes with no collisions with other decls.
- /// The point of hashing here is only to limit the number of bytes of
- /// the unique identifier to a fixed size (16 bytes).
- pub fn fullyQualifiedNameHash(self: Decl) Hash {
- // Right now we only have ZIRModule as the source. So this is simply the
- // relative name of the decl.
- return hashSimpleName(mem.spanZ(u8, self.name));
- }
-
- pub fn typedValue(self: *Decl) error{AnalysisFail}!TypedValue {
- const tvm = self.typedValueManaged() orelse return error.AnalysisFail;
- return tvm.typed_value;
- }
-
- pub fn value(self: *Decl) error{AnalysisFail}!Value {
- return (try self.typedValue()).val;
- }
-
- pub fn dump(self: *Decl) void {
- const loc = std.zig.findLineColumn(self.scope.source.bytes, self.src);
- std.debug.warn("{}:{}:{} name={} status={}", .{
- self.scope.sub_file_path,
- loc.line + 1,
- loc.column + 1,
- mem.spanZ(self.name),
- @tagName(self.analysis),
- });
- if (self.typedValueManaged()) |tvm| {
- std.debug.warn(" ty={} val={}", .{ tvm.typed_value.ty, tvm.typed_value.val });
- }
- std.debug.warn("\n", .{});
- }
-
- fn typedValueManaged(self: *Decl) ?*TypedValue.Managed {
- switch (self.analysis) {
- .initial_in_progress,
- .initial_dependency_failure,
- .initial_sema_failure,
- => return null,
- .codegen_failure,
- .codegen_failure_retryable,
- .repeat_dependency_failure,
- .repeat_sema_failure,
- .repeat_in_progress,
- .complete,
- => return &self.typed_value.most_recent,
- }
- }
- };
-
- /// Fn struct memory is owned by the Decl's TypedValue.Managed arena allocator.
- pub const Fn = struct {
- /// This memory owned by the Decl's TypedValue.Managed arena allocator.
- fn_type: Type,
- analysis: union(enum) {
- /// The value is the source instruction.
- queued: *text.Inst.Fn,
- in_progress: *Analysis,
- /// There will be a corresponding ErrorMsg in Module.failed_decls
- sema_failure,
- /// This Fn might be OK but it depends on another Decl which did not successfully complete
- /// semantic analysis.
- dependency_failure,
- success: Body,
- },
-
- /// This memory is temporary and points to stack memory for the duration
- /// of Fn analysis.
- pub const Analysis = struct {
- inner_block: Scope.Block,
- /// TODO Performance optimization idea: instead of this inst_table,
- /// use a field in the text.Inst instead to track corresponding instructions
- inst_table: std.AutoHashMap(*text.Inst, *Inst),
- needed_inst_capacity: usize,
- };
- };
-
- pub const Scope = struct {
- tag: Tag,
-
- pub fn cast(base: *Scope, comptime T: type) ?*T {
- if (base.tag != T.base_tag)
- return null;
-
- return @fieldParentPtr(T, "base", base);
- }
-
- /// Asserts the scope has a parent which is a DeclAnalysis and
- /// returns the arena Allocator.
- pub fn arena(self: *Scope) *Allocator {
- switch (self.tag) {
- .block => return self.cast(Block).?.arena,
- .decl => return &self.cast(DeclAnalysis).?.arena.allocator,
- .zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
- }
- }
-
- /// Asserts the scope has a parent which is a DeclAnalysis and
- /// returns the Decl.
- pub fn decl(self: *Scope) *Decl {
- switch (self.tag) {
- .block => return self.cast(Block).?.decl,
- .decl => return self.cast(DeclAnalysis).?.decl,
- .zir_module => unreachable,
- }
- }
-
- /// Asserts the scope has a parent which is a ZIRModule and
- /// returns it.
- pub fn namespace(self: *Scope) *ZIRModule {
- switch (self.tag) {
- .block => return self.cast(Block).?.decl.scope,
- .decl => return self.cast(DeclAnalysis).?.decl.scope,
- .zir_module => return self.cast(ZIRModule).?,
- }
- }
-
- pub fn dumpInst(self: *Scope, inst: *Inst) void {
- const zir_module = self.namespace();
- const loc = std.zig.findLineColumn(zir_module.source.bytes, inst.src);
- std.debug.warn("{}:{}:{}: {}: ty={}\n", .{
- zir_module.sub_file_path,
- loc.line + 1,
- loc.column + 1,
- @tagName(inst.tag),
- inst.ty,
- });
- }
-
- pub const Tag = enum {
- zir_module,
- block,
- decl,
- };
-
- pub const ZIRModule = struct {
- pub const base_tag: Tag = .zir_module;
- base: Scope = Scope{ .tag = base_tag },
- /// Relative to the owning package's root_src_dir.
- /// Reference to external memory, not owned by ZIRModule.
- sub_file_path: []const u8,
- source: union {
- unloaded: void,
- bytes: [:0]const u8,
- },
- contents: union {
- not_available: void,
- module: *text.Module,
- },
- status: enum {
- never_loaded,
- unloaded_success,
- unloaded_parse_failure,
- unloaded_sema_failure,
- loaded_parse_failure,
- loaded_sema_failure,
- loaded_success,
- },
-
- pub fn unload(self: *ZIRModule, allocator: *Allocator) void {
- switch (self.status) {
- .never_loaded,
- .unloaded_parse_failure,
- .unloaded_sema_failure,
- .unloaded_success,
- => {},
-
- .loaded_success => {
- allocator.free(self.source.bytes);
- self.contents.module.deinit(allocator);
- allocator.destroy(self.contents.module);
- self.status = .unloaded_success;
- },
- .loaded_sema_failure => {
- allocator.free(self.source.bytes);
- self.contents.module.deinit(allocator);
- allocator.destroy(self.contents.module);
- self.status = .unloaded_sema_failure;
- },
- .loaded_parse_failure => {
- allocator.free(self.source.bytes);
- self.status = .unloaded_parse_failure;
- },
- }
- }
-
- pub fn deinit(self: *ZIRModule, allocator: *Allocator) void {
- self.unload(allocator);
- self.* = undefined;
- }
-
- pub fn dumpSrc(self: *ZIRModule, src: usize) void {
- const loc = std.zig.findLineColumn(self.source.bytes, src);
- std.debug.warn("{}:{}:{}\n", .{ self.sub_file_path, loc.line + 1, loc.column + 1 });
- }
- };
-
- /// This is a temporary structure, references to it are valid only
- /// during semantic analysis of the block.
- pub const Block = struct {
- pub const base_tag: Tag = .block;
- base: Scope = Scope{ .tag = base_tag },
- func: *Fn,
- decl: *Decl,
- instructions: ArrayListUnmanaged(*Inst),
- /// Points to the arena allocator of DeclAnalysis
- arena: *Allocator,
- };
-
- /// This is a temporary structure, references to it are valid only
- /// during semantic analysis of the decl.
- pub const DeclAnalysis = struct {
- pub const base_tag: Tag = .decl;
- base: Scope = Scope{ .tag = base_tag },
- decl: *Decl,
- arena: std.heap.ArenaAllocator,
- };
- };
-
- pub const Body = struct {
- instructions: []*Inst,
- };
-
- pub const AllErrors = struct {
- arena: std.heap.ArenaAllocator.State,
- list: []const Message,
-
- pub const Message = struct {
- src_path: []const u8,
- line: usize,
- column: usize,
- byte_offset: usize,
- msg: []const u8,
- };
-
- pub fn deinit(self: *AllErrors, allocator: *Allocator) void {
- self.arena.promote(allocator).deinit();
- }
-
- fn add(
- arena: *std.heap.ArenaAllocator,
- errors: *std.ArrayList(Message),
- sub_file_path: []const u8,
- source: []const u8,
- simple_err_msg: ErrorMsg,
- ) !void {
- const loc = std.zig.findLineColumn(source, simple_err_msg.byte_offset);
- try errors.append(.{
- .src_path = try arena.allocator.dupe(u8, sub_file_path),
- .msg = try arena.allocator.dupe(u8, simple_err_msg.msg),
- .byte_offset = simple_err_msg.byte_offset,
- .line = loc.line,
- .column = loc.column,
- });
- }
- };
-
- pub fn deinit(self: *Module) void {
- const allocator = self.allocator;
- self.work_queue.deinit();
- {
- var it = self.decl_table.iterator();
- while (it.next()) |kv| {
- kv.value.destroy(allocator);
- }
- self.decl_table.deinit();
- }
- {
- var it = self.failed_decls.iterator();
- while (it.next()) |kv| {
- kv.value.destroy(allocator);
- }
- self.failed_decls.deinit();
- }
- {
- var it = self.failed_files.iterator();
- while (it.next()) |kv| {
- kv.value.destroy(allocator);
- }
- self.failed_files.deinit();
- }
- {
- var it = self.failed_exports.iterator();
- while (it.next()) |kv| {
- kv.value.destroy(allocator);
- }
- self.failed_exports.deinit();
- }
- {
- var it = self.decl_exports.iterator();
- while (it.next()) |kv| {
- const export_list = kv.value;
- allocator.free(export_list);
- }
- self.decl_exports.deinit();
- }
- {
- var it = self.export_owners.iterator();
- while (it.next()) |kv| {
- const export_list = kv.value;
- for (export_list) |exp| {
- allocator.destroy(exp);
- }
- allocator.free(export_list);
- }
- self.export_owners.deinit();
- }
- self.root_pkg.destroy();
- {
- self.root_scope.deinit(allocator);
- allocator.destroy(self.root_scope);
- }
- self.* = undefined;
- }
-
- pub fn target(self: Module) std.Target {
- return self.bin_file.options.target;
- }
-
- /// Detect changes to source files, perform semantic analysis, and update the output files.
- pub fn update(self: *Module) !void {
- // TODO Use the cache hash file system to detect which source files changed.
- // Here we simulate a full cache miss.
- // Analyze the root source file now.
- self.analyzeRoot(self.root_scope) catch |err| switch (err) {
- error.AnalysisFail => {
- assert(self.totalErrorCount() != 0);
- },
- else => |e| return e,
- };
-
- try self.performAllTheWork();
-
- // Unload all the source files from memory.
- self.root_scope.unload(self.allocator);
-
- try self.bin_file.flush();
- self.link_error_flags = self.bin_file.error_flags;
- }
-
- pub fn totalErrorCount(self: *Module) usize {
- return self.failed_decls.size +
- self.failed_files.size +
- self.failed_exports.size +
- @boolToInt(self.link_error_flags.no_entry_point_found);
- }
-
- pub fn getAllErrorsAlloc(self: *Module) !AllErrors {
- var arena = std.heap.ArenaAllocator.init(self.allocator);
- errdefer arena.deinit();
-
- var errors = std.ArrayList(AllErrors.Message).init(self.allocator);
- defer errors.deinit();
-
- {
- var it = self.failed_files.iterator();
- while (it.next()) |kv| {
- const scope = kv.key;
- const err_msg = kv.value;
- const source = scope.source.bytes;
- try AllErrors.add(&arena, &errors, scope.sub_file_path, source, err_msg.*);
- }
- }
- {
- var it = self.failed_decls.iterator();
- while (it.next()) |kv| {
- const decl = kv.key;
- const err_msg = kv.value;
- const source = decl.scope.source.bytes;
- try AllErrors.add(&arena, &errors, decl.scope.sub_file_path, source, err_msg.*);
- }
- }
- {
- var it = self.failed_exports.iterator();
- while (it.next()) |kv| {
- const decl = kv.key.owner_decl;
- const err_msg = kv.value;
- const source = decl.scope.source.bytes;
- try AllErrors.add(&arena, &errors, decl.scope.sub_file_path, source, err_msg.*);
- }
- }
-
- if (self.link_error_flags.no_entry_point_found) {
- try errors.append(.{
- .src_path = self.root_pkg.root_src_path,
- .line = 0,
- .column = 0,
- .byte_offset = 0,
- .msg = try std.fmt.allocPrint(&arena.allocator, "no entry point found", .{}),
- });
- }
-
- assert(errors.items.len == self.totalErrorCount());
-
- return AllErrors{
- .arena = arena.state,
- .list = try arena.allocator.dupe(AllErrors.Message, errors.items),
- };
- }
-
- const InnerError = error{ OutOfMemory, AnalysisFail };
-
- pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
- while (self.work_queue.readItem()) |work_item| switch (work_item) {
- .codegen_decl => |decl| switch (decl.analysis) {
- .initial_in_progress,
- .repeat_in_progress,
- => unreachable,
-
- .initial_sema_failure,
- .repeat_sema_failure,
- .codegen_failure,
- .initial_dependency_failure,
- .repeat_dependency_failure,
- => continue,
-
- .complete, .codegen_failure_retryable => {
- if (decl.typed_value.most_recent.typed_value.val.cast(Value.Payload.Function)) |payload| {
- switch (payload.func.analysis) {
- .queued => self.analyzeFnBody(decl, payload.func) catch |err| switch (err) {
- error.AnalysisFail => {
- if (payload.func.analysis == .queued) {
- payload.func.analysis = .dependency_failure;
- }
- continue;
- },
- else => |e| return e,
- },
- .in_progress => unreachable,
- .sema_failure, .dependency_failure => continue,
- .success => {},
- }
- }
-
- assert(decl.typed_value.most_recent.typed_value.ty.hasCodeGenBits());
-
- self.bin_file.updateDecl(self, decl) catch |err| switch (err) {
- error.OutOfMemory => return error.OutOfMemory,
- error.AnalysisFail => {
- decl.analysis = .repeat_dependency_failure;
- },
- else => {
- try self.failed_decls.ensureCapacity(self.failed_decls.size + 1);
- self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
- self.allocator,
- decl.src,
- "unable to codegen: {}",
- .{@errorName(err)},
- ));
- decl.analysis = .codegen_failure_retryable;
- },
- };
- },
- },
- };
- }
-
- fn getTextModule(self: *Module, root_scope: *Scope.ZIRModule) !*text.Module {
- switch (root_scope.status) {
- .never_loaded, .unloaded_success => {
- try self.failed_files.ensureCapacity(self.failed_files.size + 1);
-
- var keep_source = false;
- const source = try self.root_pkg.root_src_dir.readFileAllocOptions(
- self.allocator,
- self.root_pkg.root_src_path,
- std.math.maxInt(u32),
- 1,
- 0,
- );
- defer if (!keep_source) self.allocator.free(source);
-
- var keep_zir_module = false;
- const zir_module = try self.allocator.create(text.Module);
- defer if (!keep_zir_module) self.allocator.destroy(zir_module);
-
- zir_module.* = try text.parse(self.allocator, source);
- defer if (!keep_zir_module) zir_module.deinit(self.allocator);
-
- if (zir_module.error_msg) |src_err_msg| {
- self.failed_files.putAssumeCapacityNoClobber(
- root_scope,
- try ErrorMsg.create(self.allocator, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
- );
- root_scope.status = .loaded_parse_failure;
- root_scope.source = .{ .bytes = source };
- keep_source = true;
- return error.AnalysisFail;
- }
-
- root_scope.status = .loaded_success;
- root_scope.source = .{ .bytes = source };
- keep_source = true;
- root_scope.contents = .{ .module = zir_module };
- keep_zir_module = true;
-
- return zir_module;
- },
-
- .unloaded_parse_failure,
- .unloaded_sema_failure,
- .loaded_parse_failure,
- .loaded_sema_failure,
- => return error.AnalysisFail,
- .loaded_success => return root_scope.contents.module,
- }
- }
-
- fn analyzeRoot(self: *Module, root_scope: *Scope.ZIRModule) !void {
- // TODO use the cache to identify, from the modified source files, the decls which have
- // changed based on the span of memory that represents the decl in the re-parsed source file.
- // Use the cached dependency graph to recursively determine the set of decls which need
- // regeneration.
- // Here we simulate adding a source file which was previously not part of the compilation,
- // which means scanning the decls looking for exports.
- // TODO also identify decls that need to be deleted.
- switch (root_scope.status) {
- .never_loaded => {
- const src_module = try self.getTextModule(root_scope);
-
- // Here we ensure enough queue capacity to store all the decls, so that later we can use
- // appendAssumeCapacity.
- try self.work_queue.ensureUnusedCapacity(src_module.decls.len);
-
- for (src_module.decls) |decl| {
- if (decl.cast(text.Inst.Export)) |export_inst| {
- _ = try self.resolveDecl(&root_scope.base, &export_inst.base, link.ElfFile.Decl.empty);
- }
- }
- },
-
- .unloaded_parse_failure,
- .unloaded_sema_failure,
- .loaded_parse_failure,
- .loaded_sema_failure,
- .loaded_success,
- .unloaded_success,
- => {
- const src_module = try self.getTextModule(root_scope);
-
- // Look for changed decls.
- for (src_module.decls) |src_decl| {
- const name_hash = Decl.hashSimpleName(src_decl.name);
- if (self.decl_table.get(name_hash)) |kv| {
- const decl = kv.value;
- const new_contents_hash = Decl.hashSimpleName(src_decl.contents);
- if (!mem.eql(u8, &new_contents_hash, &decl.contents_hash)) {
- // TODO recursive dependency management
- std.debug.warn("noticed that '{}' changed\n", .{src_decl.name});
- self.decl_table.removeAssertDiscard(name_hash);
- const saved_link = decl.link;
- decl.destroy(self.allocator);
- if (self.export_owners.getValue(decl)) |exports| {
- @panic("TODO handle updating a decl that does an export");
- }
- const new_decl = self.resolveDecl(
- &root_scope.base,
- src_decl,
- saved_link,
- ) catch |err| switch (err) {
- error.OutOfMemory => return error.OutOfMemory,
- error.AnalysisFail => continue,
- };
- if (self.decl_exports.remove(decl)) |entry| {
- self.decl_exports.putAssumeCapacityNoClobber(new_decl, entry.value);
- }
- }
- } else if (src_decl.cast(text.Inst.Export)) |export_inst| {
- _ = try self.resolveDecl(&root_scope.base, &export_inst.base, link.ElfFile.Decl.empty);
- }
- }
- },
- }
- }
-
- fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
- // Use the Decl's arena for function memory.
- var arena = decl.typed_value.most_recent.arena.?.promote(self.allocator);
- defer decl.typed_value.most_recent.arena.?.* = arena.state;
- var analysis: Fn.Analysis = .{
- .inner_block = .{
- .func = func,
- .decl = decl,
- .instructions = .{},
- .arena = &arena.allocator,
- },
- .needed_inst_capacity = 0,
- .inst_table = std.AutoHashMap(*text.Inst, *Inst).init(self.allocator),
- };
- defer analysis.inner_block.instructions.deinit(self.allocator);
- defer analysis.inst_table.deinit();
-
- const fn_inst = func.analysis.queued;
- func.analysis = .{ .in_progress = &analysis };
-
- try self.analyzeBody(&analysis.inner_block.base, fn_inst.positionals.body);
-
- func.analysis = .{
- .success = .{
- .instructions = try arena.allocator.dupe(*Inst, analysis.inner_block.instructions.items),
- },
- };
- }
-
- fn resolveDecl(
- self: *Module,
- scope: *Scope,
- old_inst: *text.Inst,
- bin_file_link: link.ElfFile.Decl,
- ) InnerError!*Decl {
- const hash = Decl.hashSimpleName(old_inst.name);
- if (self.decl_table.get(hash)) |kv| {
- return kv.value;
- } else {
- const new_decl = blk: {
- try self.decl_table.ensureCapacity(self.decl_table.size + 1);
- const new_decl = try self.allocator.create(Decl);
- errdefer self.allocator.destroy(new_decl);
- const name = try mem.dupeZ(self.allocator, u8, old_inst.name);
- errdefer self.allocator.free(name);
- new_decl.* = .{
- .name = name,
- .scope = scope.namespace(),
- .src = old_inst.src,
- .typed_value = .{ .never_succeeded = {} },
- .analysis = .initial_in_progress,
- .contents_hash = Decl.hashSimpleName(old_inst.contents),
- .link = bin_file_link,
- };
- self.decl_table.putAssumeCapacityNoClobber(hash, new_decl);
- break :blk new_decl;
- };
-
- var decl_scope: Scope.DeclAnalysis = .{
- .decl = new_decl,
- .arena = std.heap.ArenaAllocator.init(self.allocator),
- };
- errdefer decl_scope.arena.deinit();
-
- const typed_value = self.analyzeInstConst(&decl_scope.base, old_inst) catch |err| switch (err) {
- error.OutOfMemory => return error.OutOfMemory,
- error.AnalysisFail => {
- switch (new_decl.analysis) {
- .initial_in_progress => new_decl.analysis = .initial_dependency_failure,
- .repeat_in_progress => new_decl.analysis = .repeat_dependency_failure,
- else => {},
- }
- return error.AnalysisFail;
- },
- };
- const arena_state = try decl_scope.arena.allocator.create(std.heap.ArenaAllocator.State);
-
- const has_codegen_bits = typed_value.ty.hasCodeGenBits();
- if (has_codegen_bits) {
- // We don't fully codegen the decl until later, but we do need to reserve a global
- // offset table index for it. This allows us to codegen decls out of dependency order,
- // increasing how many computations can be done in parallel.
- try self.bin_file.allocateDeclIndexes(new_decl);
- }
-
- arena_state.* = decl_scope.arena.state;
-
- new_decl.typed_value = .{
- .most_recent = .{
- .typed_value = typed_value,
- .arena = arena_state,
- },
- };
- new_decl.analysis = .complete;
- if (has_codegen_bits) {
- // We ensureCapacity when scanning for decls.
- self.work_queue.writeItemAssumeCapacity(.{ .codegen_decl = new_decl });
- }
- return new_decl;
- }
- }
-
- fn resolveCompleteDecl(self: *Module, scope: *Scope, old_inst: *text.Inst) InnerError!*Decl {
- const decl = try self.resolveDecl(scope, old_inst, link.ElfFile.Decl.empty);
- switch (decl.analysis) {
- .initial_in_progress => unreachable,
- .repeat_in_progress => unreachable,
- .initial_dependency_failure,
- .repeat_dependency_failure,
- .initial_sema_failure,
- .repeat_sema_failure,
- .codegen_failure,
- .codegen_failure_retryable,
- => return error.AnalysisFail,
-
- .complete => return decl,
- }
- }
-
- fn resolveInst(self: *Module, scope: *Scope, old_inst: *text.Inst) InnerError!*Inst {
- if (scope.cast(Scope.Block)) |block| {
- if (block.func.analysis.in_progress.inst_table.get(old_inst)) |kv| {
- return kv.value;
- }
- }
-
- const decl = try self.resolveCompleteDecl(scope, old_inst);
- const decl_ref = try self.analyzeDeclRef(scope, old_inst.src, decl);
- return self.analyzeDeref(scope, old_inst.src, decl_ref, old_inst.src);
- }
-
- fn requireRuntimeBlock(self: *Module, scope: *Scope, src: usize) !*Scope.Block {
- return scope.cast(Scope.Block) orelse
- return self.fail(scope, src, "instruction illegal outside function body", .{});
- }
-
- fn resolveInstConst(self: *Module, scope: *Scope, old_inst: *text.Inst) InnerError!TypedValue {
- const new_inst = try self.resolveInst(scope, old_inst);
- const val = try self.resolveConstValue(scope, new_inst);
- return TypedValue{
- .ty = new_inst.ty,
- .val = val,
- };
- }
-
- fn resolveConstValue(self: *Module, scope: *Scope, base: *Inst) !Value {
- return (try self.resolveDefinedValue(scope, base)) orelse
- return self.fail(scope, base.src, "unable to resolve comptime value", .{});
- }
-
- fn resolveDefinedValue(self: *Module, scope: *Scope, base: *Inst) !?Value {
- if (base.value()) |val| {
- if (val.isUndef()) {
- return self.fail(scope, base.src, "use of undefined value here causes undefined behavior", .{});
- }
- return val;
- }
- return null;
- }
-
- fn resolveConstString(self: *Module, scope: *Scope, old_inst: *text.Inst) ![]u8 {
- const new_inst = try self.resolveInst(scope, old_inst);
- const wanted_type = Type.initTag(.const_slice_u8);
- const coerced_inst = try self.coerce(scope, wanted_type, new_inst);
- const val = try self.resolveConstValue(scope, coerced_inst);
- return val.toAllocatedBytes(scope.arena());
- }
-
- fn resolveType(self: *Module, scope: *Scope, old_inst: *text.Inst) !Type {
- const new_inst = try self.resolveInst(scope, old_inst);
- const wanted_type = Type.initTag(.@"type");
- const coerced_inst = try self.coerce(scope, wanted_type, new_inst);
- const val = try self.resolveConstValue(scope, coerced_inst);
- return val.toType();
- }
-
- fn analyzeExport(self: *Module, scope: *Scope, export_inst: *text.Inst.Export) InnerError!void {
- try self.decl_exports.ensureCapacity(self.decl_exports.size + 1);
- try self.export_owners.ensureCapacity(self.export_owners.size + 1);
- const symbol_name = try self.resolveConstString(scope, export_inst.positionals.symbol_name);
- const exported_decl = try self.resolveCompleteDecl(scope, export_inst.positionals.value);
- const typed_value = exported_decl.typed_value.most_recent.typed_value;
- switch (typed_value.ty.zigTypeTag()) {
- .Fn => {},
- else => return self.fail(
- scope,
- export_inst.positionals.value.src,
- "unable to export type '{}'",
- .{typed_value.ty},
- ),
- }
- const new_export = try self.allocator.create(Export);
- errdefer self.allocator.destroy(new_export);
-
- const owner_decl = scope.decl();
-
- new_export.* = .{
- .options = .{ .name = symbol_name },
- .src = export_inst.base.src,
- .link = .{},
- .owner_decl = owner_decl,
- .status = .in_progress,
- };
-
- // Add to export_owners table.
- const eo_gop = self.export_owners.getOrPut(owner_decl) catch unreachable;
- if (!eo_gop.found_existing) {
- eo_gop.kv.value = &[0]*Export{};
- }
- eo_gop.kv.value = try self.allocator.realloc(eo_gop.kv.value, eo_gop.kv.value.len + 1);
- eo_gop.kv.value[eo_gop.kv.value.len - 1] = new_export;
- errdefer eo_gop.kv.value = self.allocator.shrink(eo_gop.kv.value, eo_gop.kv.value.len - 1);
-
- // Add to exported_decl table.
- const de_gop = self.decl_exports.getOrPut(exported_decl) catch unreachable;
- if (!de_gop.found_existing) {
- de_gop.kv.value = &[0]*Export{};
- }
- de_gop.kv.value = try self.allocator.realloc(de_gop.kv.value, de_gop.kv.value.len + 1);
- de_gop.kv.value[de_gop.kv.value.len - 1] = new_export;
- errdefer de_gop.kv.value = self.allocator.shrink(de_gop.kv.value, de_gop.kv.value.len - 1);
-
- self.bin_file.updateDeclExports(self, exported_decl, de_gop.kv.value) catch |err| switch (err) {
- error.OutOfMemory => return error.OutOfMemory,
- else => {
- try self.failed_exports.ensureCapacity(self.failed_exports.size + 1);
- self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
- self.allocator,
- export_inst.base.src,
- "unable to export: {}",
- .{@errorName(err)},
- ));
- new_export.status = .failed_retryable;
- },
- };
- }
-
- /// TODO should not need the cast on the last parameter at the callsites
- fn addNewInstArgs(
- self: *Module,
- block: *Scope.Block,
- src: usize,
- ty: Type,
- comptime T: type,
- args: Inst.Args(T),
- ) !*Inst {
- const inst = try self.addNewInst(block, src, ty, T);
- inst.args = args;
- return &inst.base;
- }
-
- fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime T: type) !*T {
- const inst = try block.arena.create(T);
- inst.* = .{
- .base = .{
- .tag = T.base_tag,
- .ty = ty,
- .src = src,
- },
- .args = undefined,
- };
- try block.instructions.append(self.allocator, &inst.base);
- return inst;
- }
-
- fn constInst(self: *Module, scope: *Scope, src: usize, typed_value: TypedValue) !*Inst {
- const const_inst = try scope.arena().create(Inst.Constant);
- const_inst.* = .{
- .base = .{
- .tag = Inst.Constant.base_tag,
- .ty = typed_value.ty,
- .src = src,
- },
- .val = typed_value.val,
- };
- return &const_inst.base;
- }
-
- fn constStr(self: *Module, scope: *Scope, src: usize, str: []const u8) !*Inst {
- const ty_payload = try scope.arena().create(Type.Payload.Array_u8_Sentinel0);
- ty_payload.* = .{ .len = str.len };
-
- const bytes_payload = try scope.arena().create(Value.Payload.Bytes);
- bytes_payload.* = .{ .data = str };
-
- return self.constInst(scope, src, .{
- .ty = Type.initPayload(&ty_payload.base),
- .val = Value.initPayload(&bytes_payload.base),
- });
- }
-
- fn constType(self: *Module, scope: *Scope, src: usize, ty: Type) !*Inst {
- return self.constInst(scope, src, .{
- .ty = Type.initTag(.type),
- .val = try ty.toValue(scope.arena()),
- });
- }
-
- fn constVoid(self: *Module, scope: *Scope, src: usize) !*Inst {
- return self.constInst(scope, src, .{
- .ty = Type.initTag(.void),
- .val = Value.initTag(.the_one_possible_value),
- });
- }
-
- fn constUndef(self: *Module, scope: *Scope, src: usize, ty: Type) !*Inst {
- return self.constInst(scope, src, .{
- .ty = ty,
- .val = Value.initTag(.undef),
- });
- }
-
- fn constBool(self: *Module, scope: *Scope, src: usize, v: bool) !*Inst {
- return self.constInst(scope, src, .{
- .ty = Type.initTag(.bool),
- .val = ([2]Value{ Value.initTag(.bool_false), Value.initTag(.bool_true) })[@boolToInt(v)],
- });
- }
-
- fn constIntUnsigned(self: *Module, scope: *Scope, src: usize, ty: Type, int: u64) !*Inst {
- const int_payload = try scope.arena().create(Value.Payload.Int_u64);
- int_payload.* = .{ .int = int };
-
- return self.constInst(scope, src, .{
- .ty = ty,
- .val = Value.initPayload(&int_payload.base),
- });
- }
-
- fn constIntSigned(self: *Module, scope: *Scope, src: usize, ty: Type, int: i64) !*Inst {
- const int_payload = try scope.arena().create(Value.Payload.Int_i64);
- int_payload.* = .{ .int = int };
-
- return self.constInst(scope, src, .{
- .ty = ty,
- .val = Value.initPayload(&int_payload.base),
- });
- }
-
- fn constIntBig(self: *Module, scope: *Scope, src: usize, ty: Type, big_int: BigIntConst) !*Inst {
- const val_payload = if (big_int.positive) blk: {
- if (big_int.to(u64)) |x| {
- return self.constIntUnsigned(scope, src, ty, x);
- } else |err| switch (err) {
- error.NegativeIntoUnsigned => unreachable,
- error.TargetTooSmall => {}, // handled below
- }
- const big_int_payload = try scope.arena().create(Value.Payload.IntBigPositive);
- big_int_payload.* = .{ .limbs = big_int.limbs };
- break :blk &big_int_payload.base;
- } else blk: {
- if (big_int.to(i64)) |x| {
- return self.constIntSigned(scope, src, ty, x);
- } else |err| switch (err) {
- error.NegativeIntoUnsigned => unreachable,
- error.TargetTooSmall => {}, // handled below
- }
- const big_int_payload = try scope.arena().create(Value.Payload.IntBigNegative);
- big_int_payload.* = .{ .limbs = big_int.limbs };
- break :blk &big_int_payload.base;
- };
-
- return self.constInst(scope, src, .{
- .ty = ty,
- .val = Value.initPayload(val_payload),
- });
- }
-
- fn analyzeInstConst(self: *Module, scope: *Scope, old_inst: *text.Inst) InnerError!TypedValue {
- const new_inst = try self.analyzeInst(scope, old_inst);
- return TypedValue{
- .ty = new_inst.ty,
- .val = try self.resolveConstValue(scope, new_inst),
- };
- }
-
- fn analyzeInst(self: *Module, scope: *Scope, old_inst: *text.Inst) InnerError!*Inst {
- switch (old_inst.tag) {
- .breakpoint => return self.analyzeInstBreakpoint(scope, old_inst.cast(text.Inst.Breakpoint).?),
- .call => return self.analyzeInstCall(scope, old_inst.cast(text.Inst.Call).?),
- .declref => return self.analyzeInstDeclRef(scope, old_inst.cast(text.Inst.DeclRef).?),
- .str => {
- const bytes = old_inst.cast(text.Inst.Str).?.positionals.bytes;
- // The bytes references memory inside the ZIR text module, which can get deallocated
- // after semantic analysis is complete. We need the memory to be in the Decl's arena.
- const arena_bytes = try scope.arena().dupe(u8, bytes);
- return self.constStr(scope, old_inst.src, arena_bytes);
- },
- .int => {
- const big_int = old_inst.cast(text.Inst.Int).?.positionals.int;
- return self.constIntBig(scope, old_inst.src, Type.initTag(.comptime_int), big_int);
- },
- .ptrtoint => return self.analyzeInstPtrToInt(scope, old_inst.cast(text.Inst.PtrToInt).?),
- .fieldptr => return self.analyzeInstFieldPtr(scope, old_inst.cast(text.Inst.FieldPtr).?),
- .deref => return self.analyzeInstDeref(scope, old_inst.cast(text.Inst.Deref).?),
- .as => return self.analyzeInstAs(scope, old_inst.cast(text.Inst.As).?),
- .@"asm" => return self.analyzeInstAsm(scope, old_inst.cast(text.Inst.Asm).?),
- .@"unreachable" => return self.analyzeInstUnreachable(scope, old_inst.cast(text.Inst.Unreachable).?),
- .@"return" => return self.analyzeInstRet(scope, old_inst.cast(text.Inst.Return).?),
- .@"fn" => return self.analyzeInstFn(scope, old_inst.cast(text.Inst.Fn).?),
- .@"export" => {
- try self.analyzeExport(scope, old_inst.cast(text.Inst.Export).?);
- return self.constVoid(scope, old_inst.src);
- },
- .primitive => return self.analyzeInstPrimitive(scope, old_inst.cast(text.Inst.Primitive).?),
- .ref => return self.analyzeInstRef(scope, old_inst.cast(text.Inst.Ref).?),
- .fntype => return self.analyzeInstFnType(scope, old_inst.cast(text.Inst.FnType).?),
- .intcast => return self.analyzeInstIntCast(scope, old_inst.cast(text.Inst.IntCast).?),
- .bitcast => return self.analyzeInstBitCast(scope, old_inst.cast(text.Inst.BitCast).?),
- .elemptr => return self.analyzeInstElemPtr(scope, old_inst.cast(text.Inst.ElemPtr).?),
- .add => return self.analyzeInstAdd(scope, old_inst.cast(text.Inst.Add).?),
- .cmp => return self.analyzeInstCmp(scope, old_inst.cast(text.Inst.Cmp).?),
- .condbr => return self.analyzeInstCondBr(scope, old_inst.cast(text.Inst.CondBr).?),
- .isnull => return self.analyzeInstIsNull(scope, old_inst.cast(text.Inst.IsNull).?),
- .isnonnull => return self.analyzeInstIsNonNull(scope, old_inst.cast(text.Inst.IsNonNull).?),
- }
- }
-
- fn analyzeInstBreakpoint(self: *Module, scope: *Scope, inst: *text.Inst.Breakpoint) InnerError!*Inst {
- const b = try self.requireRuntimeBlock(scope, inst.base.src);
- return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Breakpoint, Inst.Args(Inst.Breakpoint){});
- }
-
- fn analyzeInstRef(self: *Module, scope: *Scope, inst: *text.Inst.Ref) InnerError!*Inst {
- const decl = try self.resolveCompleteDecl(scope, inst.positionals.operand);
- return self.analyzeDeclRef(scope, inst.base.src, decl);
- }
-
- fn analyzeInstDeclRef(self: *Module, scope: *Scope, inst: *text.Inst.DeclRef) InnerError!*Inst {
- const decl_name = try self.resolveConstString(scope, inst.positionals.name);
- // This will need to get more fleshed out when there are proper structs & namespaces.
- const zir_module = scope.namespace();
- for (zir_module.contents.module.decls) |src_decl| {
- if (mem.eql(u8, src_decl.name, decl_name)) {
- const decl = try self.resolveCompleteDecl(scope, src_decl);
- return self.analyzeDeclRef(scope, inst.base.src, decl);
- }
- }
- return self.fail(scope, inst.positionals.name.src, "use of undeclared identifier '{}'", .{decl_name});
- }
-
- fn analyzeDeclRef(self: *Module, scope: *Scope, src: usize, decl: *Decl) InnerError!*Inst {
- const decl_tv = try decl.typedValue();
- const ty_payload = try scope.arena().create(Type.Payload.SingleConstPointer);
- ty_payload.* = .{ .pointee_type = decl_tv.ty };
- const val_payload = try scope.arena().create(Value.Payload.DeclRef);
- val_payload.* = .{ .decl = decl };
- return self.constInst(scope, src, .{
- .ty = Type.initPayload(&ty_payload.base),
- .val = Value.initPayload(&val_payload.base),
- });
- }
-
- fn analyzeInstCall(self: *Module, scope: *Scope, inst: *text.Inst.Call) InnerError!*Inst {
- const func = try self.resolveInst(scope, inst.positionals.func);
- if (func.ty.zigTypeTag() != .Fn)
- return self.fail(scope, inst.positionals.func.src, "type '{}' not a function", .{func.ty});
-
- const cc = func.ty.fnCallingConvention();
- if (cc == .Naked) {
- // TODO add error note: declared here
- return self.fail(
- scope,
- inst.positionals.func.src,
- "unable to call function with naked calling convention",
- .{},
- );
- }
- const call_params_len = inst.positionals.args.len;
- const fn_params_len = func.ty.fnParamLen();
- if (func.ty.fnIsVarArgs()) {
- if (call_params_len < fn_params_len) {
- // TODO add error note: declared here
- return self.fail(
- scope,
- inst.positionals.func.src,
- "expected at least {} arguments, found {}",
- .{ fn_params_len, call_params_len },
- );
- }
- return self.fail(scope, inst.base.src, "TODO implement support for calling var args functions", .{});
- } else if (fn_params_len != call_params_len) {
- // TODO add error note: declared here
- return self.fail(
- scope,
- inst.positionals.func.src,
- "expected {} arguments, found {}",
- .{ fn_params_len, call_params_len },
- );
- }
-
- if (inst.kw_args.modifier == .compile_time) {
- return self.fail(scope, inst.base.src, "TODO implement comptime function calls", .{});
- }
- if (inst.kw_args.modifier != .auto) {
- return self.fail(scope, inst.base.src, "TODO implement call with modifier {}", .{inst.kw_args.modifier});
- }
-
- // TODO handle function calls of generic functions
-
- const fn_param_types = try self.allocator.alloc(Type, fn_params_len);
- defer self.allocator.free(fn_param_types);
- func.ty.fnParamTypes(fn_param_types);
-
- const casted_args = try scope.arena().alloc(*Inst, fn_params_len);
- for (inst.positionals.args) |src_arg, i| {
- const uncasted_arg = try self.resolveInst(scope, src_arg);
- casted_args[i] = try self.coerce(scope, fn_param_types[i], uncasted_arg);
- }
-
- const b = try self.requireRuntimeBlock(scope, inst.base.src);
- return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Call, Inst.Args(Inst.Call){
- .func = func,
- .args = casted_args,
- });
- }
-
- fn analyzeInstFn(self: *Module, scope: *Scope, fn_inst: *text.Inst.Fn) InnerError!*Inst {
- const fn_type = try self.resolveType(scope, fn_inst.positionals.fn_type);
- const new_func = try scope.arena().create(Fn);
- new_func.* = .{
- .fn_type = fn_type,
- .analysis = .{ .queued = fn_inst },
- };
- const fn_payload = try scope.arena().create(Value.Payload.Function);
- fn_payload.* = .{ .func = new_func };
- return self.constInst(scope, fn_inst.base.src, .{
- .ty = fn_type,
- .val = Value.initPayload(&fn_payload.base),
- });
- }
-
- fn analyzeInstFnType(self: *Module, scope: *Scope, fntype: *text.Inst.FnType) InnerError!*Inst {
- const return_type = try self.resolveType(scope, fntype.positionals.return_type);
-
- if (return_type.zigTypeTag() == .NoReturn and
- fntype.positionals.param_types.len == 0 and
- fntype.kw_args.cc == .Unspecified)
- {
- return self.constType(scope, fntype.base.src, Type.initTag(.fn_noreturn_no_args));
- }
-
- if (return_type.zigTypeTag() == .NoReturn and
- fntype.positionals.param_types.len == 0 and
- fntype.kw_args.cc == .Naked)
- {
- return self.constType(scope, fntype.base.src, Type.initTag(.fn_naked_noreturn_no_args));
- }
-
- if (return_type.zigTypeTag() == .Void and
- fntype.positionals.param_types.len == 0 and
- fntype.kw_args.cc == .C)
- {
- return self.constType(scope, fntype.base.src, Type.initTag(.fn_ccc_void_no_args));
- }
-
- return self.fail(scope, fntype.base.src, "TODO implement fntype instruction more", .{});
- }
-
- fn analyzeInstPrimitive(self: *Module, scope: *Scope, primitive: *text.Inst.Primitive) InnerError!*Inst {
- return self.constType(scope, primitive.base.src, primitive.positionals.tag.toType());
- }
-
- fn analyzeInstAs(self: *Module, scope: *Scope, as: *text.Inst.As) InnerError!*Inst {
- const dest_type = try self.resolveType(scope, as.positionals.dest_type);
- const new_inst = try self.resolveInst(scope, as.positionals.value);
- return self.coerce(scope, dest_type, new_inst);
- }
-
- fn analyzeInstPtrToInt(self: *Module, scope: *Scope, ptrtoint: *text.Inst.PtrToInt) InnerError!*Inst {
- const ptr = try self.resolveInst(scope, ptrtoint.positionals.ptr);
- if (ptr.ty.zigTypeTag() != .Pointer) {
- return self.fail(scope, ptrtoint.positionals.ptr.src, "expected pointer, found '{}'", .{ptr.ty});
- }
- // TODO handle known-pointer-address
- const b = try self.requireRuntimeBlock(scope, ptrtoint.base.src);
- const ty = Type.initTag(.usize);
- return self.addNewInstArgs(b, ptrtoint.base.src, ty, Inst.PtrToInt, Inst.Args(Inst.PtrToInt){ .ptr = ptr });
- }
-
- fn analyzeInstFieldPtr(self: *Module, scope: *Scope, fieldptr: *text.Inst.FieldPtr) InnerError!*Inst {
- const object_ptr = try self.resolveInst(scope, fieldptr.positionals.object_ptr);
- const field_name = try self.resolveConstString(scope, fieldptr.positionals.field_name);
-
- const elem_ty = switch (object_ptr.ty.zigTypeTag()) {
- .Pointer => object_ptr.ty.elemType(),
- else => return self.fail(scope, fieldptr.positionals.object_ptr.src, "expected pointer, found '{}'", .{object_ptr.ty}),
- };
- switch (elem_ty.zigTypeTag()) {
- .Array => {
- if (mem.eql(u8, field_name, "len")) {
- const len_payload = try scope.arena().create(Value.Payload.Int_u64);
- len_payload.* = .{ .int = elem_ty.arrayLen() };
-
- const ref_payload = try scope.arena().create(Value.Payload.RefVal);
- ref_payload.* = .{ .val = Value.initPayload(&len_payload.base) };
-
- return self.constInst(scope, fieldptr.base.src, .{
- .ty = Type.initTag(.single_const_pointer_to_comptime_int),
- .val = Value.initPayload(&ref_payload.base),
- });
- } else {
- return self.fail(
- scope,
- fieldptr.positionals.field_name.src,
- "no member named '{}' in '{}'",
- .{ field_name, elem_ty },
- );
- }
- },
- else => return self.fail(scope, fieldptr.base.src, "type '{}' does not support field access", .{elem_ty}),
- }
- }
-
- fn analyzeInstIntCast(self: *Module, scope: *Scope, intcast: *text.Inst.IntCast) InnerError!*Inst {
- const dest_type = try self.resolveType(scope, intcast.positionals.dest_type);
- const new_inst = try self.resolveInst(scope, intcast.positionals.value);
-
- const dest_is_comptime_int = switch (dest_type.zigTypeTag()) {
- .ComptimeInt => true,
- .Int => false,
- else => return self.fail(
- scope,
- intcast.positionals.dest_type.src,
- "expected integer type, found '{}'",
- .{
- dest_type,
- },
- ),
- };
-
- switch (new_inst.ty.zigTypeTag()) {
- .ComptimeInt, .Int => {},
- else => return self.fail(
- scope,
- intcast.positionals.value.src,
- "expected integer type, found '{}'",
- .{new_inst.ty},
- ),
- }
-
- if (dest_is_comptime_int or new_inst.value() != null) {
- return self.coerce(scope, dest_type, new_inst);
- }
-
- return self.fail(scope, intcast.base.src, "TODO implement analyze widen or shorten int", .{});
- }
-
- fn analyzeInstBitCast(self: *Module, scope: *Scope, inst: *text.Inst.BitCast) InnerError!*Inst {
- const dest_type = try self.resolveType(scope, inst.positionals.dest_type);
- const operand = try self.resolveInst(scope, inst.positionals.operand);
- return self.bitcast(scope, dest_type, operand);
- }
-
- fn analyzeInstElemPtr(self: *Module, scope: *Scope, inst: *text.Inst.ElemPtr) InnerError!*Inst {
- const array_ptr = try self.resolveInst(scope, inst.positionals.array_ptr);
- const uncasted_index = try self.resolveInst(scope, inst.positionals.index);
- const elem_index = try self.coerce(scope, Type.initTag(.usize), uncasted_index);
-
- if (array_ptr.ty.isSinglePointer() and array_ptr.ty.elemType().zigTypeTag() == .Array) {
- if (array_ptr.value()) |array_ptr_val| {
- if (elem_index.value()) |index_val| {
- // Both array pointer and index are compile-time known.
- const index_u64 = index_val.toUnsignedInt();
- // @intCast here because it would have been impossible to construct a value that
- // required a larger index.
- const elem_ptr = try array_ptr_val.elemPtr(scope.arena(), @intCast(usize, index_u64));
-
- const type_payload = try scope.arena().create(Type.Payload.SingleConstPointer);
- type_payload.* = .{ .pointee_type = array_ptr.ty.elemType().elemType() };
-
- return self.constInst(scope, inst.base.src, .{
- .ty = Type.initPayload(&type_payload.base),
- .val = elem_ptr,
- });
- }
- }
- }
-
- return self.fail(scope, inst.base.src, "TODO implement more analyze elemptr", .{});
- }
-
- fn analyzeInstAdd(self: *Module, scope: *Scope, inst: *text.Inst.Add) InnerError!*Inst {
- const lhs = try self.resolveInst(scope, inst.positionals.lhs);
- const rhs = try self.resolveInst(scope, inst.positionals.rhs);
-
- if (lhs.ty.zigTypeTag() == .Int and rhs.ty.zigTypeTag() == .Int) {
- if (lhs.value()) |lhs_val| {
- if (rhs.value()) |rhs_val| {
- // TODO is this a performance issue? maybe we should try the operation without
- // resorting to BigInt first.
- var lhs_space: Value.BigIntSpace = undefined;
- var rhs_space: Value.BigIntSpace = undefined;
- const lhs_bigint = lhs_val.toBigInt(&lhs_space);
- const rhs_bigint = rhs_val.toBigInt(&rhs_space);
- const limbs = try scope.arena().alloc(
- std.math.big.Limb,
- std.math.max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
- );
- var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
- result_bigint.add(lhs_bigint, rhs_bigint);
- const result_limbs = result_bigint.limbs[0..result_bigint.len];
-
- if (!lhs.ty.eql(rhs.ty)) {
- return self.fail(scope, inst.base.src, "TODO implement peer type resolution", .{});
- }
-
- const val_payload = if (result_bigint.positive) blk: {
- const val_payload = try scope.arena().create(Value.Payload.IntBigPositive);
- val_payload.* = .{ .limbs = result_limbs };
- break :blk &val_payload.base;
- } else blk: {
- const val_payload = try scope.arena().create(Value.Payload.IntBigNegative);
- val_payload.* = .{ .limbs = result_limbs };
- break :blk &val_payload.base;
- };
-
- return self.constInst(scope, inst.base.src, .{
- .ty = lhs.ty,
- .val = Value.initPayload(val_payload),
- });
- }
- }
- }
-
- return self.fail(scope, inst.base.src, "TODO implement more analyze add", .{});
- }
-
- fn analyzeInstDeref(self: *Module, scope: *Scope, deref: *text.Inst.Deref) InnerError!*Inst {
- const ptr = try self.resolveInst(scope, deref.positionals.ptr);
- return self.analyzeDeref(scope, deref.base.src, ptr, deref.positionals.ptr.src);
- }
-
- fn analyzeDeref(self: *Module, scope: *Scope, src: usize, ptr: *Inst, ptr_src: usize) InnerError!*Inst {
- const elem_ty = switch (ptr.ty.zigTypeTag()) {
- .Pointer => ptr.ty.elemType(),
- else => return self.fail(scope, ptr_src, "expected pointer, found '{}'", .{ptr.ty}),
- };
- if (ptr.value()) |val| {
- return self.constInst(scope, src, .{
- .ty = elem_ty,
- .val = try val.pointerDeref(scope.arena()),
- });
- }
-
- return self.fail(scope, src, "TODO implement runtime deref", .{});
- }
-
- fn analyzeInstAsm(self: *Module, scope: *Scope, assembly: *text.Inst.Asm) InnerError!*Inst {
- const return_type = try self.resolveType(scope, assembly.positionals.return_type);
- const asm_source = try self.resolveConstString(scope, assembly.positionals.asm_source);
- const output = if (assembly.kw_args.output) |o| try self.resolveConstString(scope, o) else null;
-
- const inputs = try scope.arena().alloc([]const u8, assembly.kw_args.inputs.len);
- const clobbers = try scope.arena().alloc([]const u8, assembly.kw_args.clobbers.len);
- const args = try scope.arena().alloc(*Inst, assembly.kw_args.args.len);
-
- for (inputs) |*elem, i| {
- elem.* = try self.resolveConstString(scope, assembly.kw_args.inputs[i]);
- }
- for (clobbers) |*elem, i| {
- elem.* = try self.resolveConstString(scope, assembly.kw_args.clobbers[i]);
- }
- for (args) |*elem, i| {
- const arg = try self.resolveInst(scope, assembly.kw_args.args[i]);
- elem.* = try self.coerce(scope, Type.initTag(.usize), arg);
- }
-
- const b = try self.requireRuntimeBlock(scope, assembly.base.src);
- return self.addNewInstArgs(b, assembly.base.src, return_type, Inst.Assembly, Inst.Args(Inst.Assembly){
- .asm_source = asm_source,
- .is_volatile = assembly.kw_args.@"volatile",
- .output = output,
- .inputs = inputs,
- .clobbers = clobbers,
- .args = args,
- });
- }
-
- fn analyzeInstCmp(self: *Module, scope: *Scope, inst: *text.Inst.Cmp) InnerError!*Inst {
- const lhs = try self.resolveInst(scope, inst.positionals.lhs);
- const rhs = try self.resolveInst(scope, inst.positionals.rhs);
- const op = inst.positionals.op;
-
- const is_equality_cmp = switch (op) {
- .eq, .neq => true,
- else => false,
- };
- const lhs_ty_tag = lhs.ty.zigTypeTag();
- const rhs_ty_tag = rhs.ty.zigTypeTag();
- if (is_equality_cmp and lhs_ty_tag == .Null and rhs_ty_tag == .Null) {
- // null == null, null != null
- return self.constBool(scope, inst.base.src, op == .eq);
- } else if (is_equality_cmp and
- ((lhs_ty_tag == .Null and rhs_ty_tag == .Optional) or
- rhs_ty_tag == .Null and lhs_ty_tag == .Optional))
- {
- // comparing null with optionals
- const opt_operand = if (lhs_ty_tag == .Optional) lhs else rhs;
- if (opt_operand.value()) |opt_val| {
- const is_null = opt_val.isNull();
- return self.constBool(scope, inst.base.src, if (op == .eq) is_null else !is_null);
- }
- const b = try self.requireRuntimeBlock(scope, inst.base.src);
- switch (op) {
- .eq => return self.addNewInstArgs(
- b,
- inst.base.src,
- Type.initTag(.bool),
- Inst.IsNull,
- Inst.Args(Inst.IsNull){ .operand = opt_operand },
- ),
- .neq => return self.addNewInstArgs(
- b,
- inst.base.src,
- Type.initTag(.bool),
- Inst.IsNonNull,
- Inst.Args(Inst.IsNonNull){ .operand = opt_operand },
- ),
- else => unreachable,
- }
- } else if (is_equality_cmp and
- ((lhs_ty_tag == .Null and rhs.ty.isCPtr()) or (rhs_ty_tag == .Null and lhs.ty.isCPtr())))
- {
- return self.fail(scope, inst.base.src, "TODO implement C pointer cmp", .{});
- } else if (lhs_ty_tag == .Null or rhs_ty_tag == .Null) {
- const non_null_type = if (lhs_ty_tag == .Null) rhs.ty else lhs.ty;
- return self.fail(scope, inst.base.src, "comparison of '{}' with null", .{non_null_type});
- } else if (is_equality_cmp and
- ((lhs_ty_tag == .EnumLiteral and rhs_ty_tag == .Union) or
- (rhs_ty_tag == .EnumLiteral and lhs_ty_tag == .Union)))
- {
- return self.fail(scope, inst.base.src, "TODO implement equality comparison between a union's tag value and an enum literal", .{});
- } else if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {
- if (!is_equality_cmp) {
- return self.fail(scope, inst.base.src, "{} operator not allowed for errors", .{@tagName(op)});
- }
- return self.fail(scope, inst.base.src, "TODO implement equality comparison between errors", .{});
- } else if (lhs.ty.isNumeric() and rhs.ty.isNumeric()) {
- // This operation allows any combination of integer and float types, regardless of the
- // signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for
- // numeric types.
- return self.cmpNumeric(scope, inst.base.src, lhs, rhs, op);
- }
- return self.fail(scope, inst.base.src, "TODO implement more cmp analysis", .{});
- }
-
- fn analyzeInstIsNull(self: *Module, scope: *Scope, inst: *text.Inst.IsNull) InnerError!*Inst {
- const operand = try self.resolveInst(scope, inst.positionals.operand);
- return self.analyzeIsNull(scope, inst.base.src, operand, true);
- }
-
- fn analyzeInstIsNonNull(self: *Module, scope: *Scope, inst: *text.Inst.IsNonNull) InnerError!*Inst {
- const operand = try self.resolveInst(scope, inst.positionals.operand);
- return self.analyzeIsNull(scope, inst.base.src, operand, false);
- }
-
- fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *text.Inst.CondBr) InnerError!*Inst {
- const uncasted_cond = try self.resolveInst(scope, inst.positionals.condition);
- const cond = try self.coerce(scope, Type.initTag(.bool), uncasted_cond);
-
- if (try self.resolveDefinedValue(scope, cond)) |cond_val| {
- const body = if (cond_val.toBool()) &inst.positionals.true_body else &inst.positionals.false_body;
- try self.analyzeBody(scope, body.*);
- return self.constVoid(scope, inst.base.src);
- }
-
- const parent_block = try self.requireRuntimeBlock(scope, inst.base.src);
-
- var true_block: Scope.Block = .{
- .func = parent_block.func,
- .decl = parent_block.decl,
- .instructions = .{},
- .arena = parent_block.arena,
- };
- defer true_block.instructions.deinit(self.allocator);
- try self.analyzeBody(&true_block.base, inst.positionals.true_body);
-
- var false_block: Scope.Block = .{
- .func = parent_block.func,
- .decl = parent_block.decl,
- .instructions = .{},
- .arena = parent_block.arena,
- };
- defer false_block.instructions.deinit(self.allocator);
- try self.analyzeBody(&false_block.base, inst.positionals.false_body);
-
- return self.addNewInstArgs(parent_block, inst.base.src, Type.initTag(.void), Inst.CondBr, Inst.Args(Inst.CondBr){
- .condition = cond,
- .true_body = .{ .instructions = try scope.arena().dupe(*Inst, true_block.instructions.items) },
- .false_body = .{ .instructions = try scope.arena().dupe(*Inst, false_block.instructions.items) },
- });
- }
-
- fn wantSafety(self: *Module, scope: *Scope) bool {
- return switch (self.optimize_mode) {
- .Debug => true,
- .ReleaseSafe => true,
- .ReleaseFast => false,
- .ReleaseSmall => false,
- };
- }
-
- fn analyzeInstUnreachable(self: *Module, scope: *Scope, unreach: *text.Inst.Unreachable) InnerError!*Inst {
- const b = try self.requireRuntimeBlock(scope, unreach.base.src);
- if (self.wantSafety(scope)) {
- // TODO Once we have a panic function to call, call it here instead of this.
- _ = try self.addNewInstArgs(b, unreach.base.src, Type.initTag(.void), Inst.Breakpoint, {});
- }
- return self.addNewInstArgs(b, unreach.base.src, Type.initTag(.noreturn), Inst.Unreach, {});
- }
-
- fn analyzeInstRet(self: *Module, scope: *Scope, inst: *text.Inst.Return) InnerError!*Inst {
- const b = try self.requireRuntimeBlock(scope, inst.base.src);
- return self.addNewInstArgs(b, inst.base.src, Type.initTag(.noreturn), Inst.Ret, {});
- }
-
- fn analyzeBody(self: *Module, scope: *Scope, body: text.Module.Body) !void {
- if (scope.cast(Scope.Block)) |b| {
- const analysis = b.func.analysis.in_progress;
- analysis.needed_inst_capacity += body.instructions.len;
- try analysis.inst_table.ensureCapacity(analysis.needed_inst_capacity);
- for (body.instructions) |src_inst| {
- const new_inst = try self.analyzeInst(scope, src_inst);
- analysis.inst_table.putAssumeCapacityNoClobber(src_inst, new_inst);
- }
- } else {
- for (body.instructions) |src_inst| {
- _ = try self.analyzeInst(scope, src_inst);
- }
- }
- }
-
- fn analyzeIsNull(
- self: *Module,
- scope: *Scope,
- src: usize,
- operand: *Inst,
- invert_logic: bool,
- ) InnerError!*Inst {
- return self.fail(scope, src, "TODO implement analysis of isnull and isnotnull", .{});
- }
-
- /// Asserts that lhs and rhs types are both numeric.
- fn cmpNumeric(
- self: *Module,
- scope: *Scope,
- src: usize,
- lhs: *Inst,
- rhs: *Inst,
- op: std.math.CompareOperator,
- ) !*Inst {
- assert(lhs.ty.isNumeric());
- assert(rhs.ty.isNumeric());
-
- const lhs_ty_tag = lhs.ty.zigTypeTag();
- const rhs_ty_tag = rhs.ty.zigTypeTag();
-
- if (lhs_ty_tag == .Vector and rhs_ty_tag == .Vector) {
- if (lhs.ty.arrayLen() != rhs.ty.arrayLen()) {
- return self.fail(scope, src, "vector length mismatch: {} and {}", .{
- lhs.ty.arrayLen(),
- rhs.ty.arrayLen(),
- });
- }
- return self.fail(scope, src, "TODO implement support for vectors in cmpNumeric", .{});
- } else if (lhs_ty_tag == .Vector or rhs_ty_tag == .Vector) {
- return self.fail(scope, src, "mixed scalar and vector operands to comparison operator: '{}' and '{}'", .{
- lhs.ty,
- rhs.ty,
- });
- }
-
- if (lhs.value()) |lhs_val| {
- if (rhs.value()) |rhs_val| {
- return self.constBool(scope, src, Value.compare(lhs_val, op, rhs_val));
- }
- }
-
- // TODO handle comparisons against lazy zero values
- // Some values can be compared against zero without being runtime known or without forcing
- // a full resolution of their value, for example `@sizeOf(@Frame(function))` is known to
- // always be nonzero, and we benefit from not forcing the full evaluation and stack frame layout
- // of this function if we don't need to.
-
- // It must be a runtime comparison.
- const b = try self.requireRuntimeBlock(scope, src);
- // For floats, emit a float comparison instruction.
- const lhs_is_float = switch (lhs_ty_tag) {
- .Float, .ComptimeFloat => true,
- else => false,
- };
- const rhs_is_float = switch (rhs_ty_tag) {
- .Float, .ComptimeFloat => true,
- else => false,
- };
- if (lhs_is_float and rhs_is_float) {
- // Implicit cast the smaller one to the larger one.
- const dest_type = x: {
- if (lhs_ty_tag == .ComptimeFloat) {
- break :x rhs.ty;
- } else if (rhs_ty_tag == .ComptimeFloat) {
- break :x lhs.ty;
- }
- if (lhs.ty.floatBits(self.target()) >= rhs.ty.floatBits(self.target())) {
- break :x lhs.ty;
- } else {
- break :x rhs.ty;
- }
- };
- const casted_lhs = try self.coerce(scope, dest_type, lhs);
- const casted_rhs = try self.coerce(scope, dest_type, rhs);
- return self.addNewInstArgs(b, src, dest_type, Inst.Cmp, Inst.Args(Inst.Cmp){
- .lhs = casted_lhs,
- .rhs = casted_rhs,
- .op = op,
- });
- }
- // For mixed unsigned integer sizes, implicit cast both operands to the larger integer.
- // For mixed signed and unsigned integers, implicit cast both operands to a signed
- // integer with + 1 bit.
- // For mixed floats and integers, extract the integer part from the float, cast that to
- // a signed integer with mantissa bits + 1, and if there was any non-integral part of the float,
- // add/subtract 1.
- const lhs_is_signed = if (lhs.value()) |lhs_val|
- lhs_val.compareWithZero(.lt)
- else
- (lhs.ty.isFloat() or lhs.ty.isSignedInt());
- const rhs_is_signed = if (rhs.value()) |rhs_val|
- rhs_val.compareWithZero(.lt)
- else
- (rhs.ty.isFloat() or rhs.ty.isSignedInt());
- const dest_int_is_signed = lhs_is_signed or rhs_is_signed;
-
- var dest_float_type: ?Type = null;
-
- var lhs_bits: usize = undefined;
- if (lhs.value()) |lhs_val| {
- if (lhs_val.isUndef())
- return self.constUndef(scope, src, Type.initTag(.bool));
- const is_unsigned = if (lhs_is_float) x: {
- var bigint_space: Value.BigIntSpace = undefined;
- var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
- defer bigint.deinit();
- const zcmp = lhs_val.orderAgainstZero();
- if (lhs_val.floatHasFraction()) {
- switch (op) {
- .eq => return self.constBool(scope, src, false),
- .neq => return self.constBool(scope, src, true),
- else => {},
- }
- if (zcmp == .lt) {
- try bigint.addScalar(bigint.toConst(), -1);
- } else {
- try bigint.addScalar(bigint.toConst(), 1);
- }
- }
- lhs_bits = bigint.toConst().bitCountTwosComp();
- break :x (zcmp != .lt);
- } else x: {
- lhs_bits = lhs_val.intBitCountTwosComp();
- break :x (lhs_val.orderAgainstZero() != .lt);
- };
- lhs_bits += @boolToInt(is_unsigned and dest_int_is_signed);
- } else if (lhs_is_float) {
- dest_float_type = lhs.ty;
- } else {
- const int_info = lhs.ty.intInfo(self.target());
- lhs_bits = int_info.bits + @boolToInt(!int_info.signed and dest_int_is_signed);
- }
-
- var rhs_bits: usize = undefined;
- if (rhs.value()) |rhs_val| {
- if (rhs_val.isUndef())
- return self.constUndef(scope, src, Type.initTag(.bool));
- const is_unsigned = if (rhs_is_float) x: {
- var bigint_space: Value.BigIntSpace = undefined;
- var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(self.allocator);
- defer bigint.deinit();
- const zcmp = rhs_val.orderAgainstZero();
- if (rhs_val.floatHasFraction()) {
- switch (op) {
- .eq => return self.constBool(scope, src, false),
- .neq => return self.constBool(scope, src, true),
- else => {},
- }
- if (zcmp == .lt) {
- try bigint.addScalar(bigint.toConst(), -1);
- } else {
- try bigint.addScalar(bigint.toConst(), 1);
- }
- }
- rhs_bits = bigint.toConst().bitCountTwosComp();
- break :x (zcmp != .lt);
- } else x: {
- rhs_bits = rhs_val.intBitCountTwosComp();
- break :x (rhs_val.orderAgainstZero() != .lt);
- };
- rhs_bits += @boolToInt(is_unsigned and dest_int_is_signed);
- } else if (rhs_is_float) {
- dest_float_type = rhs.ty;
- } else {
- const int_info = rhs.ty.intInfo(self.target());
- rhs_bits = int_info.bits + @boolToInt(!int_info.signed and dest_int_is_signed);
- }
-
- const dest_type = if (dest_float_type) |ft| ft else blk: {
- const max_bits = std.math.max(lhs_bits, rhs_bits);
- const casted_bits = std.math.cast(u16, max_bits) catch |err| switch (err) {
- error.Overflow => return self.fail(scope, src, "{} exceeds maximum integer bit count", .{max_bits}),
- };
- break :blk try self.makeIntType(scope, dest_int_is_signed, casted_bits);
- };
- const casted_lhs = try self.coerce(scope, dest_type, lhs);
- const casted_rhs = try self.coerce(scope, dest_type, lhs);
-
- return self.addNewInstArgs(b, src, dest_type, Inst.Cmp, Inst.Args(Inst.Cmp){
- .lhs = casted_lhs,
- .rhs = casted_rhs,
- .op = op,
- });
- }
-
- fn makeIntType(self: *Module, scope: *Scope, signed: bool, bits: u16) !Type {
- if (signed) {
- const int_payload = try scope.arena().create(Type.Payload.IntSigned);
- int_payload.* = .{ .bits = bits };
- return Type.initPayload(&int_payload.base);
- } else {
- const int_payload = try scope.arena().create(Type.Payload.IntUnsigned);
- int_payload.* = .{ .bits = bits };
- return Type.initPayload(&int_payload.base);
- }
- }
-
- fn coerce(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
- // If the types are the same, we can return the operand.
- if (dest_type.eql(inst.ty))
- return inst;
-
- const in_memory_result = coerceInMemoryAllowed(dest_type, inst.ty);
- if (in_memory_result == .ok) {
- return self.bitcast(scope, dest_type, inst);
- }
-
- // *[N]T to []T
- if (inst.ty.isSinglePointer() and dest_type.isSlice() and
- (!inst.ty.pointerIsConst() or dest_type.pointerIsConst()))
- {
- const array_type = inst.ty.elemType();
- const dst_elem_type = dest_type.elemType();
- if (array_type.zigTypeTag() == .Array and
- coerceInMemoryAllowed(dst_elem_type, array_type.elemType()) == .ok)
- {
- return self.coerceArrayPtrToSlice(scope, dest_type, inst);
- }
- }
-
- // comptime_int to fixed-width integer
- if (inst.ty.zigTypeTag() == .ComptimeInt and dest_type.zigTypeTag() == .Int) {
- // The representation is already correct; we only need to make sure it fits in the destination type.
- const val = inst.value().?; // comptime_int always has comptime known value
- if (!val.intFitsInType(dest_type, self.target())) {
- return self.fail(scope, inst.src, "type {} cannot represent integer value {}", .{ inst.ty, val });
- }
- return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
- }
-
- // integer widening
- if (inst.ty.zigTypeTag() == .Int and dest_type.zigTypeTag() == .Int) {
- const src_info = inst.ty.intInfo(self.target());
- const dst_info = dest_type.intInfo(self.target());
- if (src_info.signed == dst_info.signed and dst_info.bits >= src_info.bits) {
- if (inst.value()) |val| {
- return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
- } else {
- return self.fail(scope, inst.src, "TODO implement runtime integer widening", .{});
- }
- } else {
- return self.fail(scope, inst.src, "TODO implement more int widening {} to {}", .{ inst.ty, dest_type });
- }
- }
-
- return self.fail(scope, inst.src, "TODO implement type coercion from {} to {}", .{ inst.ty, dest_type });
- }
-
- fn bitcast(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
- if (inst.value()) |val| {
- // Keep the comptime Value representation; take the new type.
- return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
- }
- // TODO validate the type size and other compile errors
- const b = try self.requireRuntimeBlock(scope, inst.src);
- return self.addNewInstArgs(b, inst.src, dest_type, Inst.BitCast, Inst.Args(Inst.BitCast){ .operand = inst });
- }
-
- fn coerceArrayPtrToSlice(self: *Module, scope: *Scope, dest_type: Type, inst: *Inst) !*Inst {
- if (inst.value()) |val| {
- // The comptime Value representation is compatible with both types.
- return self.constInst(scope, inst.src, .{ .ty = dest_type, .val = val });
- }
- return self.fail(scope, inst.src, "TODO implement coerceArrayPtrToSlice runtime instruction", .{});
- }
-
- fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: var) InnerError {
- @setCold(true);
- try self.failed_decls.ensureCapacity(self.failed_decls.size + 1);
- try self.failed_files.ensureCapacity(self.failed_files.size + 1);
- const err_msg = try ErrorMsg.create(self.allocator, src, format, args);
- switch (scope.tag) {
- .decl => {
- const decl = scope.cast(Scope.DeclAnalysis).?.decl;
- switch (decl.analysis) {
- .initial_in_progress => decl.analysis = .initial_sema_failure,
- .repeat_in_progress => decl.analysis = .repeat_sema_failure,
- else => unreachable,
- }
- self.failed_decls.putAssumeCapacityNoClobber(decl, err_msg);
- },
- .block => {
- const block = scope.cast(Scope.Block).?;
- block.func.analysis = .sema_failure;
- self.failed_decls.putAssumeCapacityNoClobber(block.decl, err_msg);
- },
- .zir_module => {
- const zir_module = scope.cast(Scope.ZIRModule).?;
- zir_module.status = .loaded_sema_failure;
- self.failed_files.putAssumeCapacityNoClobber(zir_module, err_msg);
- },
- }
- return error.AnalysisFail;
- }
-
- const InMemoryCoercionResult = enum {
- ok,
- no_match,
- };
-
- fn coerceInMemoryAllowed(dest_type: Type, src_type: Type) InMemoryCoercionResult {
- if (dest_type.eql(src_type))
- return .ok;
-
- // TODO: implement more of this function
-
- return .no_match;
- }
-};
-
-pub const ErrorMsg = struct {
- byte_offset: usize,
- msg: []const u8,
-
- pub fn create(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !*ErrorMsg {
- const self = try allocator.create(ErrorMsg);
- errdefer allocator.destroy(self);
- self.* = try init(allocator, byte_offset, format, args);
- return self;
- }
-
- /// Assumes the ErrorMsg struct and msg were both allocated with allocator.
- pub fn destroy(self: *ErrorMsg, allocator: *Allocator) void {
- self.deinit(allocator);
- allocator.destroy(self);
- }
-
- pub fn init(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !ErrorMsg {
- return ErrorMsg{
- .byte_offset = byte_offset,
- .msg = try std.fmt.allocPrint(allocator, format, args),
- };
- }
-
- pub fn deinit(self: *ErrorMsg, allocator: *Allocator) void {
- allocator.free(self.msg);
- self.* = undefined;
- }
-};
diff --git a/src-self-hosted/ir/text.zig b/src-self-hosted/ir/text.zig
@@ -1,1476 +0,0 @@
-//! This file has to do with parsing and rendering the ZIR text format.
-
-const std = @import("std");
-const mem = std.mem;
-const Allocator = std.mem.Allocator;
-const assert = std.debug.assert;
-const BigIntConst = std.math.big.int.Const;
-const BigIntMutable = std.math.big.int.Mutable;
-const Type = @import("../type.zig").Type;
-const Value = @import("../value.zig").Value;
-const TypedValue = @import("../TypedValue.zig");
-const ir = @import("../ir.zig");
-
-/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for
-/// in-memory, analyzed instructions with types and values.
-pub const Inst = struct {
- tag: Tag,
- /// Byte offset into the source.
- src: usize,
- name: []const u8,
-
- /// Slice into the source of the part after the = and before the next instruction.
- contents: []const u8 = &[0]u8{},
-
- /// These names are used directly as the instruction names in the text format.
- pub const Tag = enum {
- breakpoint,
- call,
- /// Represents a reference to a global decl by name.
- /// The syntax `@foo` is equivalent to `declref("foo")`.
- declref,
- str,
- int,
- ptrtoint,
- fieldptr,
- deref,
- as,
- @"asm",
- @"unreachable",
- @"return",
- @"fn",
- @"export",
- primitive,
- ref,
- fntype,
- intcast,
- bitcast,
- elemptr,
- add,
- cmp,
- condbr,
- isnull,
- isnonnull,
- };
-
- pub fn TagToType(tag: Tag) type {
- return switch (tag) {
- .breakpoint => Breakpoint,
- .call => Call,
- .declref => DeclRef,
- .str => Str,
- .int => Int,
- .ptrtoint => PtrToInt,
- .fieldptr => FieldPtr,
- .deref => Deref,
- .as => As,
- .@"asm" => Asm,
- .@"unreachable" => Unreachable,
- .@"return" => Return,
- .@"fn" => Fn,
- .@"export" => Export,
- .primitive => Primitive,
- .ref => Ref,
- .fntype => FnType,
- .intcast => IntCast,
- .bitcast => BitCast,
- .elemptr => ElemPtr,
- .add => Add,
- .cmp => Cmp,
- .condbr => CondBr,
- .isnull => IsNull,
- .isnonnull => IsNonNull,
- };
- }
-
- pub fn cast(base: *Inst, comptime T: type) ?*T {
- if (base.tag != T.base_tag)
- return null;
-
- return @fieldParentPtr(T, "base", base);
- }
-
- pub const Breakpoint = struct {
- pub const base_tag = Tag.breakpoint;
- base: Inst,
-
- positionals: struct {},
- kw_args: struct {},
- };
-
- pub const Call = struct {
- pub const base_tag = Tag.call;
- base: Inst,
-
- positionals: struct {
- func: *Inst,
- args: []*Inst,
- },
- kw_args: struct {
- modifier: std.builtin.CallOptions.Modifier = .auto,
- },
- };
-
- pub const DeclRef = struct {
- pub const base_tag = Tag.declref;
- base: Inst,
-
- positionals: struct {
- name: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Str = struct {
- pub const base_tag = Tag.str;
- base: Inst,
-
- positionals: struct {
- bytes: []const u8,
- },
- kw_args: struct {},
- };
-
- pub const Int = struct {
- pub const base_tag = Tag.int;
- base: Inst,
-
- positionals: struct {
- int: BigIntConst,
- },
- kw_args: struct {},
- };
-
- pub const PtrToInt = struct {
- pub const base_tag = Tag.ptrtoint;
- base: Inst,
-
- positionals: struct {
- ptr: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const FieldPtr = struct {
- pub const base_tag = Tag.fieldptr;
- base: Inst,
-
- positionals: struct {
- object_ptr: *Inst,
- field_name: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Deref = struct {
- pub const base_tag = Tag.deref;
- base: Inst,
-
- positionals: struct {
- ptr: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const As = struct {
- pub const base_tag = Tag.as;
- base: Inst,
-
- positionals: struct {
- dest_type: *Inst,
- value: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Asm = struct {
- pub const base_tag = Tag.@"asm";
- base: Inst,
-
- positionals: struct {
- asm_source: *Inst,
- return_type: *Inst,
- },
- kw_args: struct {
- @"volatile": bool = false,
- output: ?*Inst = null,
- inputs: []*Inst = &[0]*Inst{},
- clobbers: []*Inst = &[0]*Inst{},
- args: []*Inst = &[0]*Inst{},
- },
- };
-
- pub const Unreachable = struct {
- pub const base_tag = Tag.@"unreachable";
- base: Inst,
-
- positionals: struct {},
- kw_args: struct {},
- };
-
- pub const Return = struct {
- pub const base_tag = Tag.@"return";
- base: Inst,
-
- positionals: struct {},
- kw_args: struct {},
- };
-
- pub const Fn = struct {
- pub const base_tag = Tag.@"fn";
- base: Inst,
-
- positionals: struct {
- fn_type: *Inst,
- body: Module.Body,
- },
- kw_args: struct {},
- };
-
- pub const Export = struct {
- pub const base_tag = Tag.@"export";
- base: Inst,
-
- positionals: struct {
- symbol_name: *Inst,
- value: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Ref = struct {
- pub const base_tag = Tag.ref;
- base: Inst,
-
- positionals: struct {
- operand: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Primitive = struct {
- pub const base_tag = Tag.primitive;
- base: Inst,
-
- positionals: struct {
- tag: BuiltinType,
- },
- kw_args: struct {},
-
- pub const BuiltinType = enum {
- isize,
- usize,
- c_short,
- c_ushort,
- c_int,
- c_uint,
- c_long,
- c_ulong,
- c_longlong,
- c_ulonglong,
- c_longdouble,
- c_void,
- f16,
- f32,
- f64,
- f128,
- bool,
- void,
- noreturn,
- type,
- anyerror,
- comptime_int,
- comptime_float,
-
- fn toType(self: BuiltinType) Type {
- return switch (self) {
- .isize => Type.initTag(.isize),
- .usize => Type.initTag(.usize),
- .c_short => Type.initTag(.c_short),
- .c_ushort => Type.initTag(.c_ushort),
- .c_int => Type.initTag(.c_int),
- .c_uint => Type.initTag(.c_uint),
- .c_long => Type.initTag(.c_long),
- .c_ulong => Type.initTag(.c_ulong),
- .c_longlong => Type.initTag(.c_longlong),
- .c_ulonglong => Type.initTag(.c_ulonglong),
- .c_longdouble => Type.initTag(.c_longdouble),
- .c_void => Type.initTag(.c_void),
- .f16 => Type.initTag(.f16),
- .f32 => Type.initTag(.f32),
- .f64 => Type.initTag(.f64),
- .f128 => Type.initTag(.f128),
- .bool => Type.initTag(.bool),
- .void => Type.initTag(.void),
- .noreturn => Type.initTag(.noreturn),
- .type => Type.initTag(.type),
- .anyerror => Type.initTag(.anyerror),
- .comptime_int => Type.initTag(.comptime_int),
- .comptime_float => Type.initTag(.comptime_float),
- };
- }
- };
- };
-
- pub const FnType = struct {
- pub const base_tag = Tag.fntype;
- base: Inst,
-
- positionals: struct {
- param_types: []*Inst,
- return_type: *Inst,
- },
- kw_args: struct {
- cc: std.builtin.CallingConvention = .Unspecified,
- },
- };
-
- pub const IntCast = struct {
- pub const base_tag = Tag.intcast;
- base: Inst,
-
- positionals: struct {
- dest_type: *Inst,
- value: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const BitCast = struct {
- pub const base_tag = Tag.bitcast;
- base: Inst,
-
- positionals: struct {
- dest_type: *Inst,
- operand: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const ElemPtr = struct {
- pub const base_tag = Tag.elemptr;
- base: Inst,
-
- positionals: struct {
- array_ptr: *Inst,
- index: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Add = struct {
- pub const base_tag = Tag.add;
- base: Inst,
-
- positionals: struct {
- lhs: *Inst,
- rhs: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const Cmp = struct {
- pub const base_tag = Tag.cmp;
- base: Inst,
-
- positionals: struct {
- lhs: *Inst,
- op: std.math.CompareOperator,
- rhs: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const CondBr = struct {
- pub const base_tag = Tag.condbr;
- base: Inst,
-
- positionals: struct {
- condition: *Inst,
- true_body: Module.Body,
- false_body: Module.Body,
- },
- kw_args: struct {},
- };
-
- pub const IsNull = struct {
- pub const base_tag = Tag.isnull;
- base: Inst,
-
- positionals: struct {
- operand: *Inst,
- },
- kw_args: struct {},
- };
-
- pub const IsNonNull = struct {
- pub const base_tag = Tag.isnonnull;
- base: Inst,
-
- positionals: struct {
- operand: *Inst,
- },
- kw_args: struct {},
- };
-};
-
-pub const ErrorMsg = struct {
- byte_offset: usize,
- msg: []const u8,
-};
-
-pub const Module = struct {
- decls: []*Inst,
- arena: std.heap.ArenaAllocator,
- error_msg: ?ErrorMsg = null,
-
- pub const Body = struct {
- instructions: []*Inst,
- };
-
- pub fn deinit(self: *Module, allocator: *Allocator) void {
- allocator.free(self.decls);
- self.arena.deinit();
- self.* = undefined;
- }
-
- /// This is a debugging utility for rendering the tree to stderr.
- pub fn dump(self: Module) void {
- self.writeToStream(std.heap.page_allocator, std.io.getStdErr().outStream()) catch {};
- }
-
- const InstPtrTable = std.AutoHashMap(*Inst, struct { index: usize, fn_body: ?*Module.Body });
-
- /// The allocator is used for temporary storage, but this function always returns
- /// with no resources allocated.
- pub fn writeToStream(self: Module, allocator: *Allocator, stream: var) !void {
- // First, build a map of *Inst to @ or % indexes
- var inst_table = InstPtrTable.init(allocator);
- defer inst_table.deinit();
-
- try inst_table.ensureCapacity(self.decls.len);
-
- for (self.decls) |decl, decl_i| {
- try inst_table.putNoClobber(decl, .{ .index = decl_i, .fn_body = null });
-
- if (decl.cast(Inst.Fn)) |fn_inst| {
- for (fn_inst.positionals.body.instructions) |inst, inst_i| {
- try inst_table.putNoClobber(inst, .{ .index = inst_i, .fn_body = &fn_inst.positionals.body });
- }
- }
- }
-
- for (self.decls) |decl, i| {
- try stream.print("@{} ", .{i});
- try self.writeInstToStream(stream, decl, &inst_table);
- try stream.writeByte('\n');
- }
- }
-
- fn writeInstToStream(
- self: Module,
- stream: var,
- decl: *Inst,
- inst_table: *const InstPtrTable,
- ) @TypeOf(stream).Error!void {
- // TODO I tried implementing this with an inline for loop and hit a compiler bug
- switch (decl.tag) {
- .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, decl, inst_table),
- .call => return self.writeInstToStreamGeneric(stream, .call, decl, inst_table),
- .declref => return self.writeInstToStreamGeneric(stream, .declref, decl, inst_table),
- .str => return self.writeInstToStreamGeneric(stream, .str, decl, inst_table),
- .int => return self.writeInstToStreamGeneric(stream, .int, decl, inst_table),
- .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, decl, inst_table),
- .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, decl, inst_table),
- .deref => return self.writeInstToStreamGeneric(stream, .deref, decl, inst_table),
- .as => return self.writeInstToStreamGeneric(stream, .as, decl, inst_table),
- .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", decl, inst_table),
- .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", decl, inst_table),
- .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", decl, inst_table),
- .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", decl, inst_table),
- .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", decl, inst_table),
- .ref => return self.writeInstToStreamGeneric(stream, .ref, decl, inst_table),
- .primitive => return self.writeInstToStreamGeneric(stream, .primitive, decl, inst_table),
- .fntype => return self.writeInstToStreamGeneric(stream, .fntype, decl, inst_table),
- .intcast => return self.writeInstToStreamGeneric(stream, .intcast, decl, inst_table),
- .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, decl, inst_table),
- .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, decl, inst_table),
- .add => return self.writeInstToStreamGeneric(stream, .add, decl, inst_table),
- .cmp => return self.writeInstToStreamGeneric(stream, .cmp, decl, inst_table),
- .condbr => return self.writeInstToStreamGeneric(stream, .condbr, decl, inst_table),
- .isnull => return self.writeInstToStreamGeneric(stream, .isnull, decl, inst_table),
- .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, decl, inst_table),
- }
- }
-
- fn writeInstToStreamGeneric(
- self: Module,
- stream: var,
- comptime inst_tag: Inst.Tag,
- base: *Inst,
- inst_table: *const InstPtrTable,
- ) !void {
- const SpecificInst = Inst.TagToType(inst_tag);
- const inst = @fieldParentPtr(SpecificInst, "base", base);
- const Positionals = @TypeOf(inst.positionals);
- try stream.writeAll("= " ++ @tagName(inst_tag) ++ "(");
- const pos_fields = @typeInfo(Positionals).Struct.fields;
- inline for (pos_fields) |arg_field, i| {
- if (i != 0) {
- try stream.writeAll(", ");
- }
- try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name), inst_table);
- }
-
- comptime var need_comma = pos_fields.len != 0;
- const KW_Args = @TypeOf(inst.kw_args);
- inline for (@typeInfo(KW_Args).Struct.fields) |arg_field, i| {
- if (@typeInfo(arg_field.field_type) == .Optional) {
- if (@field(inst.kw_args, arg_field.name)) |non_optional| {
- if (need_comma) try stream.writeAll(", ");
- try stream.print("{}=", .{arg_field.name});
- try self.writeParamToStream(stream, non_optional, inst_table);
- need_comma = true;
- }
- } else {
- if (need_comma) try stream.writeAll(", ");
- try stream.print("{}=", .{arg_field.name});
- try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name), inst_table);
- need_comma = true;
- }
- }
-
- try stream.writeByte(')');
- }
-
- fn writeParamToStream(self: Module, stream: var, param: var, inst_table: *const InstPtrTable) !void {
- if (@typeInfo(@TypeOf(param)) == .Enum) {
- return stream.writeAll(@tagName(param));
- }
- switch (@TypeOf(param)) {
- *Inst => return self.writeInstParamToStream(stream, param, inst_table),
- []*Inst => {
- try stream.writeByte('[');
- for (param) |inst, i| {
- if (i != 0) {
- try stream.writeAll(", ");
- }
- try self.writeInstParamToStream(stream, inst, inst_table);
- }
- try stream.writeByte(']');
- },
- Module.Body => {
- try stream.writeAll("{\n");
- for (param.instructions) |inst, i| {
- try stream.print(" %{} ", .{i});
- try self.writeInstToStream(stream, inst, inst_table);
- try stream.writeByte('\n');
- }
- try stream.writeByte('}');
- },
- bool => return stream.writeByte("01"[@boolToInt(param)]),
- []u8, []const u8 => return std.zig.renderStringLiteral(param, stream),
- BigIntConst => return stream.print("{}", .{param}),
- else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
- }
- }
-
- fn writeInstParamToStream(self: Module, stream: var, inst: *Inst, inst_table: *const InstPtrTable) !void {
- const info = inst_table.getValue(inst).?;
- const prefix = if (info.fn_body == null) "@" else "%";
- try stream.print("{}{}", .{ prefix, info.index });
- }
-};
-
-pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module {
- var global_name_map = std.StringHashMap(usize).init(allocator);
- defer global_name_map.deinit();
-
- var parser: Parser = .{
- .allocator = allocator,
- .arena = std.heap.ArenaAllocator.init(allocator),
- .i = 0,
- .source = source,
- .global_name_map = &global_name_map,
- .decls = .{},
- .unnamed_index = 0,
- };
- errdefer parser.arena.deinit();
-
- parser.parseRoot() catch |err| switch (err) {
- error.ParseFailure => {
- assert(parser.error_msg != null);
- },
- else => |e| return e,
- };
-
- return Module{
- .decls = parser.decls.toOwnedSlice(allocator),
- .arena = parser.arena,
- .error_msg = parser.error_msg,
- };
-}
-
-const Parser = struct {
- allocator: *Allocator,
- arena: std.heap.ArenaAllocator,
- i: usize,
- source: [:0]const u8,
- decls: std.ArrayListUnmanaged(*Inst),
- global_name_map: *std.StringHashMap(usize),
- error_msg: ?ErrorMsg = null,
- unnamed_index: usize,
-
- const Body = struct {
- instructions: std.ArrayList(*Inst),
- name_map: std.StringHashMap(usize),
- };
-
- fn parseBody(self: *Parser) !Module.Body {
- var body_context = Body{
- .instructions = std.ArrayList(*Inst).init(self.allocator),
- .name_map = std.StringHashMap(usize).init(self.allocator),
- };
- defer body_context.instructions.deinit();
- defer body_context.name_map.deinit();
-
- try requireEatBytes(self, "{");
- skipSpace(self);
-
- while (true) : (self.i += 1) switch (self.source[self.i]) {
- ';' => _ = try skipToAndOver(self, '\n'),
- '%' => {
- self.i += 1;
- const ident = try skipToAndOver(self, ' ');
- skipSpace(self);
- try requireEatBytes(self, "=");
- skipSpace(self);
- const inst = try parseInstruction(self, &body_context, ident);
- const ident_index = body_context.instructions.items.len;
- if (try body_context.name_map.put(ident, ident_index)) |_| {
- return self.fail("redefinition of identifier '{}'", .{ident});
- }
- try body_context.instructions.append(inst);
- continue;
- },
- ' ', '\n' => continue,
- '}' => {
- self.i += 1;
- break;
- },
- else => |byte| return self.failByte(byte),
- };
-
- // Move the instructions to the arena
- const instrs = try self.arena.allocator.alloc(*Inst, body_context.instructions.items.len);
- mem.copy(*Inst, instrs, body_context.instructions.items);
- return Module.Body{ .instructions = instrs };
- }
-
- fn parseStringLiteral(self: *Parser) ![]u8 {
- const start = self.i;
- try self.requireEatBytes("\"");
-
- while (true) : (self.i += 1) switch (self.source[self.i]) {
- '"' => {
- self.i += 1;
- const span = self.source[start..self.i];
- var bad_index: usize = undefined;
- const parsed = std.zig.parseStringLiteral(&self.arena.allocator, span, &bad_index) catch |err| switch (err) {
- error.InvalidCharacter => {
- self.i = start + bad_index;
- const bad_byte = self.source[self.i];
- return self.fail("invalid string literal character: '{c}'\n", .{bad_byte});
- },
- else => |e| return e,
- };
- return parsed;
- },
- '\\' => {
- self.i += 1;
- continue;
- },
- 0 => return self.failByte(0),
- else => continue,
- };
- }
-
- fn parseIntegerLiteral(self: *Parser) !BigIntConst {
- const start = self.i;
- if (self.source[self.i] == '-') self.i += 1;
- while (true) : (self.i += 1) switch (self.source[self.i]) {
- '0'...'9' => continue,
- else => break,
- };
- const number_text = self.source[start..self.i];
- const base = 10;
- // TODO reuse the same array list for this
- const limbs_buffer_len = std.math.big.int.calcSetStringLimbsBufferLen(base, number_text.len);
- const limbs_buffer = try self.allocator.alloc(std.math.big.Limb, limbs_buffer_len);
- defer self.allocator.free(limbs_buffer);
- const limb_len = std.math.big.int.calcSetStringLimbCount(base, number_text.len);
- const limbs = try self.arena.allocator.alloc(std.math.big.Limb, limb_len);
- var result = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
- result.setString(base, number_text, limbs_buffer, self.allocator) catch |err| switch (err) {
- error.InvalidCharacter => {
- self.i = start;
- return self.fail("invalid digit in integer literal", .{});
- },
- };
- return result.toConst();
- }
-
- fn parseRoot(self: *Parser) !void {
- // The IR format is designed so that it can be tokenized and parsed at the same time.
- while (true) {
- switch (self.source[self.i]) {
- ';' => _ = try skipToAndOver(self, '\n'),
- '@' => {
- self.i += 1;
- const ident = try skipToAndOver(self, ' ');
- skipSpace(self);
- try requireEatBytes(self, "=");
- skipSpace(self);
- const inst = try parseInstruction(self, null, ident);
- const ident_index = self.decls.items.len;
- if (try self.global_name_map.put(ident, ident_index)) |_| {
- return self.fail("redefinition of identifier '{}'", .{ident});
- }
- try self.decls.append(self.allocator, inst);
- },
- ' ', '\n' => self.i += 1,
- 0 => break,
- else => |byte| return self.fail("unexpected byte: '{c}'", .{byte}),
- }
- }
- }
-
- fn eatByte(self: *Parser, byte: u8) bool {
- if (self.source[self.i] != byte) return false;
- self.i += 1;
- return true;
- }
-
- fn skipSpace(self: *Parser) void {
- while (self.source[self.i] == ' ' or self.source[self.i] == '\n') {
- self.i += 1;
- }
- }
-
- fn requireEatBytes(self: *Parser, bytes: []const u8) !void {
- const start = self.i;
- for (bytes) |byte| {
- if (self.source[self.i] != byte) {
- self.i = start;
- return self.fail("expected '{}'", .{bytes});
- }
- self.i += 1;
- }
- }
-
- fn skipToAndOver(self: *Parser, byte: u8) ![]const u8 {
- const start_i = self.i;
- while (self.source[self.i] != 0) : (self.i += 1) {
- if (self.source[self.i] == byte) {
- const result = self.source[start_i..self.i];
- self.i += 1;
- return result;
- }
- }
- return self.fail("unexpected EOF", .{});
- }
-
- /// ParseFailure is an internal error code; handled in `parse`.
- const InnerError = error{ ParseFailure, OutOfMemory };
-
- fn failByte(self: *Parser, byte: u8) InnerError {
- if (byte == 0) {
- return self.fail("unexpected EOF", .{});
- } else {
- return self.fail("unexpected byte: '{c}'", .{byte});
- }
- }
-
- fn fail(self: *Parser, comptime format: []const u8, args: var) InnerError {
- @setCold(true);
- self.error_msg = ErrorMsg{
- .byte_offset = self.i,
- .msg = try std.fmt.allocPrint(&self.arena.allocator, format, args),
- };
- return error.ParseFailure;
- }
-
- fn parseInstruction(self: *Parser, body_ctx: ?*Body, name: []const u8) InnerError!*Inst {
- const contents_start = self.i;
- const fn_name = try skipToAndOver(self, '(');
- inline for (@typeInfo(Inst.Tag).Enum.fields) |field| {
- if (mem.eql(u8, field.name, fn_name)) {
- const tag = @field(Inst.Tag, field.name);
- return parseInstructionGeneric(self, field.name, Inst.TagToType(tag), body_ctx, name, contents_start);
- }
- }
- return self.fail("unknown instruction '{}'", .{fn_name});
- }
-
- fn parseInstructionGeneric(
- self: *Parser,
- comptime fn_name: []const u8,
- comptime InstType: type,
- body_ctx: ?*Body,
- inst_name: []const u8,
- contents_start: usize,
- ) InnerError!*Inst {
- const inst_specific = try self.arena.allocator.create(InstType);
- inst_specific.base = .{
- .name = inst_name,
- .src = self.i,
- .tag = InstType.base_tag,
- };
-
- if (@hasField(InstType, "ty")) {
- inst_specific.ty = opt_type orelse {
- return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
- };
- }
-
- const Positionals = @TypeOf(inst_specific.positionals);
- inline for (@typeInfo(Positionals).Struct.fields) |arg_field| {
- if (self.source[self.i] == ',') {
- self.i += 1;
- skipSpace(self);
- } else if (self.source[self.i] == ')') {
- return self.fail("expected positional parameter '{}'", .{arg_field.name});
- }
- @field(inst_specific.positionals, arg_field.name) = try parseParameterGeneric(
- self,
- arg_field.field_type,
- body_ctx,
- );
- skipSpace(self);
- }
-
- const KW_Args = @TypeOf(inst_specific.kw_args);
- inst_specific.kw_args = .{}; // assign defaults
- skipSpace(self);
- while (eatByte(self, ',')) {
- skipSpace(self);
- const name = try skipToAndOver(self, '=');
- inline for (@typeInfo(KW_Args).Struct.fields) |arg_field| {
- const field_name = arg_field.name;
- if (mem.eql(u8, name, field_name)) {
- const NonOptional = switch (@typeInfo(arg_field.field_type)) {
- .Optional => |info| info.child,
- else => arg_field.field_type,
- };
- @field(inst_specific.kw_args, field_name) = try parseParameterGeneric(self, NonOptional, body_ctx);
- break;
- }
- } else {
- return self.fail("unrecognized keyword parameter: '{}'", .{name});
- }
- skipSpace(self);
- }
- try requireEatBytes(self, ")");
-
- inst_specific.base.contents = self.source[contents_start..self.i];
-
- return &inst_specific.base;
- }
-
- fn parseParameterGeneric(self: *Parser, comptime T: type, body_ctx: ?*Body) !T {
- if (@typeInfo(T) == .Enum) {
- const start = self.i;
- while (true) : (self.i += 1) switch (self.source[self.i]) {
- ' ', '\n', ',', ')' => {
- const enum_name = self.source[start..self.i];
- return std.meta.stringToEnum(T, enum_name) orelse {
- return self.fail("tag '{}' not a member of enum '{}'", .{ enum_name, @typeName(T) });
- };
- },
- 0 => return self.failByte(0),
- else => continue,
- };
- }
- switch (T) {
- Module.Body => return parseBody(self),
- bool => {
- const bool_value = switch (self.source[self.i]) {
- '0' => false,
- '1' => true,
- else => |byte| return self.fail("expected '0' or '1' for boolean value, found {c}", .{byte}),
- };
- self.i += 1;
- return bool_value;
- },
- []*Inst => {
- try requireEatBytes(self, "[");
- skipSpace(self);
- if (eatByte(self, ']')) return &[0]*Inst{};
-
- var instructions = std.ArrayList(*Inst).init(&self.arena.allocator);
- while (true) {
- skipSpace(self);
- try instructions.append(try parseParameterInst(self, body_ctx));
- skipSpace(self);
- if (!eatByte(self, ',')) break;
- }
- try requireEatBytes(self, "]");
- return instructions.toOwnedSlice();
- },
- *Inst => return parseParameterInst(self, body_ctx),
- []u8, []const u8 => return self.parseStringLiteral(),
- BigIntConst => return self.parseIntegerLiteral(),
- else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
- }
- return self.fail("TODO parse parameter {}", .{@typeName(T)});
- }
-
- fn parseParameterInst(self: *Parser, body_ctx: ?*Body) !*Inst {
- const local_ref = switch (self.source[self.i]) {
- '@' => false,
- '%' => true,
- else => |byte| return self.fail("unexpected byte: '{c}'", .{byte}),
- };
- const map = if (local_ref)
- if (body_ctx) |bc|
- &bc.name_map
- else
- return self.fail("referencing a % instruction in global scope", .{})
- else
- self.global_name_map;
-
- self.i += 1;
- const name_start = self.i;
- while (true) : (self.i += 1) switch (self.source[self.i]) {
- 0, ' ', '\n', ',', ')', ']' => break,
- else => continue,
- };
- const ident = self.source[name_start..self.i];
- const kv = map.get(ident) orelse {
- const bad_name = self.source[name_start - 1 .. self.i];
- const src = name_start - 1;
- if (local_ref) {
- self.i = src;
- return self.fail("unrecognized identifier: {}", .{bad_name});
- } else {
- const name = try self.arena.allocator.create(Inst.Str);
- name.* = .{
- .base = .{
- .name = try self.generateName(),
- .src = src,
- .tag = Inst.Str.base_tag,
- },
- .positionals = .{ .bytes = ident },
- .kw_args = .{},
- };
- const declref = try self.arena.allocator.create(Inst.DeclRef);
- declref.* = .{
- .base = .{
- .name = try self.generateName(),
- .src = src,
- .tag = Inst.DeclRef.base_tag,
- },
- .positionals = .{ .name = &name.base },
- .kw_args = .{},
- };
- return &declref.base;
- }
- };
- if (local_ref) {
- return body_ctx.?.instructions.items[kv.value];
- } else {
- return self.decls.items[kv.value];
- }
- }
-
- fn generateName(self: *Parser) ![]u8 {
- const result = try std.fmt.allocPrint(&self.arena.allocator, "unnamed${}", .{self.unnamed_index});
- self.unnamed_index += 1;
- return result;
- }
-};
-
-pub fn emit_zir(allocator: *Allocator, old_module: ir.Module) !Module {
- var ctx: EmitZIR = .{
- .allocator = allocator,
- .decls = .{},
- .decl_table = std.AutoHashMap(*ir.Inst, *Inst).init(allocator),
- .arena = std.heap.ArenaAllocator.init(allocator),
- .old_module = &old_module,
- };
- defer ctx.decls.deinit(allocator);
- defer ctx.decl_table.deinit();
- errdefer ctx.arena.deinit();
-
- try ctx.emit();
-
- return Module{
- .decls = ctx.decls.toOwnedSlice(allocator),
- .arena = ctx.arena,
- };
-}
-
-const EmitZIR = struct {
- allocator: *Allocator,
- arena: std.heap.ArenaAllocator,
- old_module: *const ir.Module,
- decls: std.ArrayListUnmanaged(*Inst),
- decl_table: std.AutoHashMap(*ir.Inst, *Inst),
-
- fn emit(self: *EmitZIR) !void {
- var it = self.old_module.decl_exports.iterator();
- while (it.next()) |kv| {
- const decl = kv.key;
- const exports = kv.value;
- const export_value = try self.emitTypedValue(decl.src, decl.typed_value.most_recent.typed_value);
- for (exports) |module_export| {
- const symbol_name = try self.emitStringLiteral(module_export.src, module_export.options.name);
- const export_inst = try self.arena.allocator.create(Inst.Export);
- export_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = module_export.src,
- .tag = Inst.Export.base_tag,
- },
- .positionals = .{
- .symbol_name = symbol_name,
- .value = export_value,
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &export_inst.base);
- }
- }
- }
-
- fn resolveInst(self: *EmitZIR, inst_table: *const std.AutoHashMap(*ir.Inst, *Inst), inst: *ir.Inst) !*Inst {
- if (inst.cast(ir.Inst.Constant)) |const_inst| {
- if (self.decl_table.getValue(inst)) |decl| {
- return decl;
- }
- const new_decl = try self.emitTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
- try self.decl_table.putNoClobber(inst, new_decl);
- return new_decl;
- } else {
- return inst_table.getValue(inst).?;
- }
- }
-
- fn emitComptimeIntVal(self: *EmitZIR, src: usize, val: Value) !*Inst {
- const big_int_space = try self.arena.allocator.create(Value.BigIntSpace);
- const int_inst = try self.arena.allocator.create(Inst.Int);
- int_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Int.base_tag,
- },
- .positionals = .{
- .int = val.toBigInt(big_int_space),
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &int_inst.base);
- return &int_inst.base;
- }
-
- fn emitTypedValue(self: *EmitZIR, src: usize, typed_value: TypedValue) Allocator.Error!*Inst {
- const allocator = &self.arena.allocator;
- switch (typed_value.ty.zigTypeTag()) {
- .Pointer => {
- const ptr_elem_type = typed_value.ty.elemType();
- switch (ptr_elem_type.zigTypeTag()) {
- .Array => {
- // TODO more checks to make sure this can be emitted as a string literal
- //const array_elem_type = ptr_elem_type.elemType();
- //if (array_elem_type.eql(Type.initTag(.u8)) and
- // ptr_elem_type.hasSentinel(Value.initTag(.zero)))
- //{
- //}
- const bytes = typed_value.val.toAllocatedBytes(allocator) catch |err| switch (err) {
- error.AnalysisFail => unreachable,
- else => |e| return e,
- };
- return self.emitStringLiteral(src, bytes);
- },
- else => |t| std.debug.panic("TODO implement emitTypedValue for pointer to {}", .{@tagName(t)}),
- }
- },
- .ComptimeInt => return self.emitComptimeIntVal(src, typed_value.val),
- .Int => {
- const as_inst = try self.arena.allocator.create(Inst.As);
- as_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.As.base_tag,
- },
- .positionals = .{
- .dest_type = try self.emitType(src, typed_value.ty),
- .value = try self.emitComptimeIntVal(src, typed_value.val),
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &as_inst.base);
-
- return &as_inst.base;
- },
- .Type => {
- const ty = typed_value.val.toType();
- return self.emitType(src, ty);
- },
- .Fn => {
- const module_fn = typed_value.val.cast(Value.Payload.Function).?.func;
-
- var inst_table = std.AutoHashMap(*ir.Inst, *Inst).init(self.allocator);
- defer inst_table.deinit();
-
- var instructions = std.ArrayList(*Inst).init(self.allocator);
- defer instructions.deinit();
-
- try self.emitBody(module_fn.analysis.success, &inst_table, &instructions);
-
- const fn_type = try self.emitType(src, module_fn.fn_type);
-
- const arena_instrs = try self.arena.allocator.alloc(*Inst, instructions.items.len);
- mem.copy(*Inst, arena_instrs, instructions.items);
-
- const fn_inst = try self.arena.allocator.create(Inst.Fn);
- fn_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Fn.base_tag,
- },
- .positionals = .{
- .fn_type = fn_type,
- .body = .{ .instructions = arena_instrs },
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &fn_inst.base);
- return &fn_inst.base;
- },
- else => |t| std.debug.panic("TODO implement emitTypedValue for {}", .{@tagName(t)}),
- }
- }
-
- fn emitTrivial(self: *EmitZIR, src: usize, comptime T: type) Allocator.Error!*Inst {
- const new_inst = try self.arena.allocator.create(T);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = T.base_tag,
- },
- .positionals = .{},
- .kw_args = .{},
- };
- return &new_inst.base;
- }
-
- fn emitBody(
- self: *EmitZIR,
- body: ir.Module.Body,
- inst_table: *std.AutoHashMap(*ir.Inst, *Inst),
- instructions: *std.ArrayList(*Inst),
- ) Allocator.Error!void {
- for (body.instructions) |inst| {
- const new_inst = switch (inst.tag) {
- .breakpoint => try self.emitTrivial(inst.src, Inst.Breakpoint),
- .call => blk: {
- const old_inst = inst.cast(ir.Inst.Call).?;
- const new_inst = try self.arena.allocator.create(Inst.Call);
-
- const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
- for (args) |*elem, i| {
- elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
- }
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.Call.base_tag,
- },
- .positionals = .{
- .func = try self.resolveInst(inst_table, old_inst.args.func),
- .args = args,
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .unreach => try self.emitTrivial(inst.src, Inst.Unreachable),
- .ret => try self.emitTrivial(inst.src, Inst.Return),
- .constant => unreachable, // excluded from function bodies
- .assembly => blk: {
- const old_inst = inst.cast(ir.Inst.Assembly).?;
- const new_inst = try self.arena.allocator.create(Inst.Asm);
-
- const inputs = try self.arena.allocator.alloc(*Inst, old_inst.args.inputs.len);
- for (inputs) |*elem, i| {
- elem.* = try self.emitStringLiteral(inst.src, old_inst.args.inputs[i]);
- }
-
- const clobbers = try self.arena.allocator.alloc(*Inst, old_inst.args.clobbers.len);
- for (clobbers) |*elem, i| {
- elem.* = try self.emitStringLiteral(inst.src, old_inst.args.clobbers[i]);
- }
-
- const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
- for (args) |*elem, i| {
- elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
- }
-
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.Asm.base_tag,
- },
- .positionals = .{
- .asm_source = try self.emitStringLiteral(inst.src, old_inst.args.asm_source),
- .return_type = try self.emitType(inst.src, inst.ty),
- },
- .kw_args = .{
- .@"volatile" = old_inst.args.is_volatile,
- .output = if (old_inst.args.output) |o|
- try self.emitStringLiteral(inst.src, o)
- else
- null,
- .inputs = inputs,
- .clobbers = clobbers,
- .args = args,
- },
- };
- break :blk &new_inst.base;
- },
- .ptrtoint => blk: {
- const old_inst = inst.cast(ir.Inst.PtrToInt).?;
- const new_inst = try self.arena.allocator.create(Inst.PtrToInt);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.PtrToInt.base_tag,
- },
- .positionals = .{
- .ptr = try self.resolveInst(inst_table, old_inst.args.ptr),
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .bitcast => blk: {
- const old_inst = inst.cast(ir.Inst.BitCast).?;
- const new_inst = try self.arena.allocator.create(Inst.BitCast);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.BitCast.base_tag,
- },
- .positionals = .{
- .dest_type = try self.emitType(inst.src, inst.ty),
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .cmp => blk: {
- const old_inst = inst.cast(ir.Inst.Cmp).?;
- const new_inst = try self.arena.allocator.create(Inst.Cmp);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.Cmp.base_tag,
- },
- .positionals = .{
- .lhs = try self.resolveInst(inst_table, old_inst.args.lhs),
- .rhs = try self.resolveInst(inst_table, old_inst.args.rhs),
- .op = old_inst.args.op,
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .condbr => blk: {
- const old_inst = inst.cast(ir.Inst.CondBr).?;
-
- var true_body = std.ArrayList(*Inst).init(self.allocator);
- var false_body = std.ArrayList(*Inst).init(self.allocator);
-
- defer true_body.deinit();
- defer false_body.deinit();
-
- try self.emitBody(old_inst.args.true_body, inst_table, &true_body);
- try self.emitBody(old_inst.args.false_body, inst_table, &false_body);
-
- const new_inst = try self.arena.allocator.create(Inst.CondBr);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.CondBr.base_tag,
- },
- .positionals = .{
- .condition = try self.resolveInst(inst_table, old_inst.args.condition),
- .true_body = .{ .instructions = true_body.toOwnedSlice() },
- .false_body = .{ .instructions = false_body.toOwnedSlice() },
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .isnull => blk: {
- const old_inst = inst.cast(ir.Inst.IsNull).?;
- const new_inst = try self.arena.allocator.create(Inst.IsNull);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.IsNull.base_tag,
- },
- .positionals = .{
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- .isnonnull => blk: {
- const old_inst = inst.cast(ir.Inst.IsNonNull).?;
- const new_inst = try self.arena.allocator.create(Inst.IsNonNull);
- new_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = inst.src,
- .tag = Inst.IsNonNull.base_tag,
- },
- .positionals = .{
- .operand = try self.resolveInst(inst_table, old_inst.args.operand),
- },
- .kw_args = .{},
- };
- break :blk &new_inst.base;
- },
- };
- try instructions.append(new_inst);
- try inst_table.putNoClobber(inst, new_inst);
- }
- }
-
- fn emitType(self: *EmitZIR, src: usize, ty: Type) Allocator.Error!*Inst {
- switch (ty.tag()) {
- .isize => return self.emitPrimitiveType(src, .isize),
- .usize => return self.emitPrimitiveType(src, .usize),
- .c_short => return self.emitPrimitiveType(src, .c_short),
- .c_ushort => return self.emitPrimitiveType(src, .c_ushort),
- .c_int => return self.emitPrimitiveType(src, .c_int),
- .c_uint => return self.emitPrimitiveType(src, .c_uint),
- .c_long => return self.emitPrimitiveType(src, .c_long),
- .c_ulong => return self.emitPrimitiveType(src, .c_ulong),
- .c_longlong => return self.emitPrimitiveType(src, .c_longlong),
- .c_ulonglong => return self.emitPrimitiveType(src, .c_ulonglong),
- .c_longdouble => return self.emitPrimitiveType(src, .c_longdouble),
- .c_void => return self.emitPrimitiveType(src, .c_void),
- .f16 => return self.emitPrimitiveType(src, .f16),
- .f32 => return self.emitPrimitiveType(src, .f32),
- .f64 => return self.emitPrimitiveType(src, .f64),
- .f128 => return self.emitPrimitiveType(src, .f128),
- .anyerror => return self.emitPrimitiveType(src, .anyerror),
- else => switch (ty.zigTypeTag()) {
- .Bool => return self.emitPrimitiveType(src, .bool),
- .Void => return self.emitPrimitiveType(src, .void),
- .NoReturn => return self.emitPrimitiveType(src, .noreturn),
- .Type => return self.emitPrimitiveType(src, .type),
- .ComptimeInt => return self.emitPrimitiveType(src, .comptime_int),
- .ComptimeFloat => return self.emitPrimitiveType(src, .comptime_float),
- .Fn => {
- const param_types = try self.allocator.alloc(Type, ty.fnParamLen());
- defer self.allocator.free(param_types);
-
- ty.fnParamTypes(param_types);
- const emitted_params = try self.arena.allocator.alloc(*Inst, param_types.len);
- for (param_types) |param_type, i| {
- emitted_params[i] = try self.emitType(src, param_type);
- }
-
- const fntype_inst = try self.arena.allocator.create(Inst.FnType);
- fntype_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.FnType.base_tag,
- },
- .positionals = .{
- .param_types = emitted_params,
- .return_type = try self.emitType(src, ty.fnReturnType()),
- },
- .kw_args = .{
- .cc = ty.fnCallingConvention(),
- },
- };
- try self.decls.append(self.allocator, &fntype_inst.base);
- return &fntype_inst.base;
- },
- else => std.debug.panic("TODO implement emitType for {}", .{ty}),
- },
- }
- }
-
- fn autoName(self: *EmitZIR) ![]u8 {
- return std.fmt.allocPrint(&self.arena.allocator, "{}", .{self.decls.items.len});
- }
-
- fn emitPrimitiveType(self: *EmitZIR, src: usize, tag: Inst.Primitive.BuiltinType) !*Inst {
- const primitive_inst = try self.arena.allocator.create(Inst.Primitive);
- primitive_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Primitive.base_tag,
- },
- .positionals = .{
- .tag = tag,
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &primitive_inst.base);
- return &primitive_inst.base;
- }
-
- fn emitStringLiteral(self: *EmitZIR, src: usize, str: []const u8) !*Inst {
- const str_inst = try self.arena.allocator.create(Inst.Str);
- str_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Str.base_tag,
- },
- .positionals = .{
- .bytes = str,
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &str_inst.base);
-
- const ref_inst = try self.arena.allocator.create(Inst.Ref);
- ref_inst.* = .{
- .base = .{
- .name = try self.autoName(),
- .src = src,
- .tag = Inst.Ref.base_tag,
- },
- .positionals = .{
- .operand = &str_inst.base,
- },
- .kw_args = .{},
- };
- try self.decls.append(self.allocator, &ref_inst.base);
-
- return &ref_inst.base;
- }
-};
diff --git a/src-self-hosted/link.zig b/src-self-hosted/link.zig
@@ -3,6 +3,7 @@ const mem = std.mem;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const ir = @import("ir.zig");
+const Module = @import("Module.zig");
const fs = std.fs;
const elf = std.elf;
const codegen = @import("codegen.zig");
@@ -45,8 +46,8 @@ pub fn writeFilePath(
allocator: *Allocator,
dir: fs.Dir,
sub_path: []const u8,
- module: ir.Module,
- errors: *std.ArrayList(ir.ErrorMsg),
+ module: Module,
+ errors: *std.ArrayList(Module.ErrorMsg),
) !void {
const options: Options = .{
.target = module.target,
@@ -755,7 +756,7 @@ pub const ElfFile = struct {
};
}
- pub fn allocateDeclIndexes(self: *ElfFile, decl: *ir.Module.Decl) !void {
+ pub fn allocateDeclIndexes(self: *ElfFile, decl: *Module.Decl) !void {
if (decl.link.local_sym_index != 0) return;
try self.local_symbols.ensureCapacity(self.allocator, self.local_symbols.items.len + 1);
@@ -784,7 +785,7 @@ pub const ElfFile = struct {
};
}
- pub fn updateDecl(self: *ElfFile, module: *ir.Module, decl: *ir.Module.Decl) !void {
+ pub fn updateDecl(self: *ElfFile, module: *Module, decl: *Module.Decl) !void {
var code_buffer = std.ArrayList(u8).init(self.allocator);
defer code_buffer.deinit();
@@ -878,16 +879,16 @@ pub const ElfFile = struct {
try self.file.pwriteAll(code, file_offset);
// Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
- const decl_exports = module.decl_exports.getValue(decl) orelse &[0]*ir.Module.Export{};
+ const decl_exports = module.decl_exports.getValue(decl) orelse &[0]*Module.Export{};
return self.updateDeclExports(module, decl, decl_exports);
}
/// Must be called only after a successful call to `updateDecl`.
pub fn updateDeclExports(
self: *ElfFile,
- module: *ir.Module,
- decl: *const ir.Module.Decl,
- exports: []const *ir.Module.Export,
+ module: *Module,
+ decl: *const Module.Decl,
+ exports: []const *Module.Export,
) !void {
try self.global_symbols.ensureCapacity(self.allocator, self.global_symbols.items.len + exports.len);
const typed_value = decl.typed_value.most_recent.typed_value;
@@ -900,7 +901,7 @@ pub const ElfFile = struct {
try module.failed_exports.ensureCapacity(module.failed_exports.size + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
- try ir.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
+ try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
);
continue;
}
@@ -918,7 +919,7 @@ pub const ElfFile = struct {
try module.failed_exports.ensureCapacity(module.failed_exports.size + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
- try ir.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
+ try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
);
continue;
},
diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig
@@ -6,9 +6,10 @@ const process = std.process;
const Allocator = mem.Allocator;
const ArrayList = std.ArrayList;
const ast = std.zig.ast;
-const ir = @import("ir.zig");
+const Module = @import("Module.zig");
const link = @import("link.zig");
const Package = @import("Package.zig");
+const zir = @import("zir.zig");
const LibCInstallation = @import("libc_installation.zig").LibCInstallation;
@@ -438,7 +439,7 @@ fn buildOutputType(
const root_pkg = try Package.create(gpa, fs.cwd(), ".", src_path);
errdefer root_pkg.destroy();
- const root_scope = try gpa.create(ir.Module.Scope.ZIRModule);
+ const root_scope = try gpa.create(Module.Scope.ZIRModule);
errdefer gpa.destroy(root_scope);
root_scope.* = .{
.sub_file_path = root_pkg.root_src_path,
@@ -447,19 +448,19 @@ fn buildOutputType(
.status = .never_loaded,
};
- break :blk ir.Module{
+ break :blk Module{
.allocator = gpa,
.root_pkg = root_pkg,
.root_scope = root_scope,
.bin_file = &bin_file,
.optimize_mode = .Debug,
- .decl_table = std.AutoHashMap(ir.Module.Decl.Hash, *ir.Module.Decl).init(gpa),
- .decl_exports = std.AutoHashMap(*ir.Module.Decl, []*ir.Module.Export).init(gpa),
- .export_owners = std.AutoHashMap(*ir.Module.Decl, []*ir.Module.Export).init(gpa),
- .failed_decls = std.AutoHashMap(*ir.Module.Decl, *ir.ErrorMsg).init(gpa),
- .failed_files = std.AutoHashMap(*ir.Module.Scope.ZIRModule, *ir.ErrorMsg).init(gpa),
- .failed_exports = std.AutoHashMap(*ir.Module.Export, *ir.ErrorMsg).init(gpa),
- .work_queue = std.fifo.LinearFifo(ir.Module.WorkItem, .Dynamic).init(gpa),
+ .decl_table = std.AutoHashMap(Module.Decl.Hash, *Module.Decl).init(gpa),
+ .decl_exports = std.AutoHashMap(*Module.Decl, []*Module.Export).init(gpa),
+ .export_owners = std.AutoHashMap(*Module.Decl, []*Module.Export).init(gpa),
+ .failed_decls = std.AutoHashMap(*Module.Decl, *Module.ErrorMsg).init(gpa),
+ .failed_files = std.AutoHashMap(*Module.Scope.ZIRModule, *Module.ErrorMsg).init(gpa),
+ .failed_exports = std.AutoHashMap(*Module.Export, *Module.ErrorMsg).init(gpa),
+ .work_queue = std.fifo.LinearFifo(Module.WorkItem, .Dynamic).init(gpa),
};
};
defer module.deinit();
@@ -491,7 +492,7 @@ fn buildOutputType(
}
}
-fn updateModule(gpa: *Allocator, module: *ir.Module, zir_out_path: ?[]const u8) !void {
+fn updateModule(gpa: *Allocator, module: *Module, zir_out_path: ?[]const u8) !void {
try module.update();
var errors = try module.getAllErrorsAlloc();
@@ -509,7 +510,7 @@ fn updateModule(gpa: *Allocator, module: *ir.Module, zir_out_path: ?[]const u8)
}
if (zir_out_path) |zop| {
- var new_zir_module = try ir.text.emit_zir(gpa, module.*);
+ var new_zir_module = try zir.emit(gpa, module.*);
defer new_zir_module.deinit(gpa);
const baf = try io.BufferedAtomicFile.create(gpa, fs.cwd(), zop, .{});
diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig
@@ -6,7 +6,7 @@ const BigIntConst = std.math.big.int.Const;
const BigIntMutable = std.math.big.int.Mutable;
const Target = std.Target;
const Allocator = std.mem.Allocator;
-const ir = @import("ir.zig");
+const Module = @import("Module.zig");
/// This is the raw data, with no bookkeeping, no memory awareness,
/// no de-duplication, and no type system awareness.
@@ -904,7 +904,7 @@ pub const Value = extern union {
pub const Function = struct {
base: Payload = Payload{ .tag = .function },
- func: *ir.Module.Fn,
+ func: *Module.Fn,
};
pub const ArraySentinel0_u8_Type = struct {
@@ -926,7 +926,7 @@ pub const Value = extern union {
/// Represents a pointer to a decl, not the value of the decl.
pub const DeclRef = struct {
base: Payload = Payload{ .tag = .decl_ref },
- decl: *ir.Module.Decl,
+ decl: *Module.Decl,
};
pub const ElemPtr = struct {
diff --git a/src-self-hosted/zir.zig b/src-self-hosted/zir.zig
@@ -0,0 +1,1477 @@
+//! This file has to do with parsing and rendering the ZIR text format.
+
+const std = @import("std");
+const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const BigIntConst = std.math.big.int.Const;
+const BigIntMutable = std.math.big.int.Mutable;
+const Type = @import("type.zig").Type;
+const Value = @import("value.zig").Value;
+const TypedValue = @import("TypedValue.zig");
+const ir = @import("ir.zig");
+const IrModule = @import("Module.zig");
+
+/// These are instructions that correspond to the ZIR text format. See `ir.Inst` for
+/// in-memory, analyzed instructions with types and values.
+pub const Inst = struct {
+ tag: Tag,
+ /// Byte offset into the source.
+ src: usize,
+ name: []const u8,
+
+ /// Slice into the source of the part after the = and before the next instruction.
+ contents: []const u8 = &[0]u8{},
+
+ /// These names are used directly as the instruction names in the text format.
+ pub const Tag = enum {
+ breakpoint,
+ call,
+ /// Represents a reference to a global decl by name.
+ /// The syntax `@foo` is equivalent to `declref("foo")`.
+ declref,
+ str,
+ int,
+ ptrtoint,
+ fieldptr,
+ deref,
+ as,
+ @"asm",
+ @"unreachable",
+ @"return",
+ @"fn",
+ @"export",
+ primitive,
+ ref,
+ fntype,
+ intcast,
+ bitcast,
+ elemptr,
+ add,
+ cmp,
+ condbr,
+ isnull,
+ isnonnull,
+ };
+
+ pub fn TagToType(tag: Tag) type {
+ return switch (tag) {
+ .breakpoint => Breakpoint,
+ .call => Call,
+ .declref => DeclRef,
+ .str => Str,
+ .int => Int,
+ .ptrtoint => PtrToInt,
+ .fieldptr => FieldPtr,
+ .deref => Deref,
+ .as => As,
+ .@"asm" => Asm,
+ .@"unreachable" => Unreachable,
+ .@"return" => Return,
+ .@"fn" => Fn,
+ .@"export" => Export,
+ .primitive => Primitive,
+ .ref => Ref,
+ .fntype => FnType,
+ .intcast => IntCast,
+ .bitcast => BitCast,
+ .elemptr => ElemPtr,
+ .add => Add,
+ .cmp => Cmp,
+ .condbr => CondBr,
+ .isnull => IsNull,
+ .isnonnull => IsNonNull,
+ };
+ }
+
+ pub fn cast(base: *Inst, comptime T: type) ?*T {
+ if (base.tag != T.base_tag)
+ return null;
+
+ return @fieldParentPtr(T, "base", base);
+ }
+
+ pub const Breakpoint = struct {
+ pub const base_tag = Tag.breakpoint;
+ base: Inst,
+
+ positionals: struct {},
+ kw_args: struct {},
+ };
+
+ pub const Call = struct {
+ pub const base_tag = Tag.call;
+ base: Inst,
+
+ positionals: struct {
+ func: *Inst,
+ args: []*Inst,
+ },
+ kw_args: struct {
+ modifier: std.builtin.CallOptions.Modifier = .auto,
+ },
+ };
+
+ pub const DeclRef = struct {
+ pub const base_tag = Tag.declref;
+ base: Inst,
+
+ positionals: struct {
+ name: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Str = struct {
+ pub const base_tag = Tag.str;
+ base: Inst,
+
+ positionals: struct {
+ bytes: []const u8,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Int = struct {
+ pub const base_tag = Tag.int;
+ base: Inst,
+
+ positionals: struct {
+ int: BigIntConst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const PtrToInt = struct {
+ pub const base_tag = Tag.ptrtoint;
+ base: Inst,
+
+ positionals: struct {
+ ptr: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const FieldPtr = struct {
+ pub const base_tag = Tag.fieldptr;
+ base: Inst,
+
+ positionals: struct {
+ object_ptr: *Inst,
+ field_name: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Deref = struct {
+ pub const base_tag = Tag.deref;
+ base: Inst,
+
+ positionals: struct {
+ ptr: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const As = struct {
+ pub const base_tag = Tag.as;
+ base: Inst,
+
+ positionals: struct {
+ dest_type: *Inst,
+ value: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Asm = struct {
+ pub const base_tag = Tag.@"asm";
+ base: Inst,
+
+ positionals: struct {
+ asm_source: *Inst,
+ return_type: *Inst,
+ },
+ kw_args: struct {
+ @"volatile": bool = false,
+ output: ?*Inst = null,
+ inputs: []*Inst = &[0]*Inst{},
+ clobbers: []*Inst = &[0]*Inst{},
+ args: []*Inst = &[0]*Inst{},
+ },
+ };
+
+ pub const Unreachable = struct {
+ pub const base_tag = Tag.@"unreachable";
+ base: Inst,
+
+ positionals: struct {},
+ kw_args: struct {},
+ };
+
+ pub const Return = struct {
+ pub const base_tag = Tag.@"return";
+ base: Inst,
+
+ positionals: struct {},
+ kw_args: struct {},
+ };
+
+ pub const Fn = struct {
+ pub const base_tag = Tag.@"fn";
+ base: Inst,
+
+ positionals: struct {
+ fn_type: *Inst,
+ body: Module.Body,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Export = struct {
+ pub const base_tag = Tag.@"export";
+ base: Inst,
+
+ positionals: struct {
+ symbol_name: *Inst,
+ value: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Ref = struct {
+ pub const base_tag = Tag.ref;
+ base: Inst,
+
+ positionals: struct {
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Primitive = struct {
+ pub const base_tag = Tag.primitive;
+ base: Inst,
+
+ positionals: struct {
+ tag: BuiltinType,
+ },
+ kw_args: struct {},
+
+ pub const BuiltinType = enum {
+ isize,
+ usize,
+ c_short,
+ c_ushort,
+ c_int,
+ c_uint,
+ c_long,
+ c_ulong,
+ c_longlong,
+ c_ulonglong,
+ c_longdouble,
+ c_void,
+ f16,
+ f32,
+ f64,
+ f128,
+ bool,
+ void,
+ noreturn,
+ type,
+ anyerror,
+ comptime_int,
+ comptime_float,
+
+ fn toType(self: BuiltinType) Type {
+ return switch (self) {
+ .isize => Type.initTag(.isize),
+ .usize => Type.initTag(.usize),
+ .c_short => Type.initTag(.c_short),
+ .c_ushort => Type.initTag(.c_ushort),
+ .c_int => Type.initTag(.c_int),
+ .c_uint => Type.initTag(.c_uint),
+ .c_long => Type.initTag(.c_long),
+ .c_ulong => Type.initTag(.c_ulong),
+ .c_longlong => Type.initTag(.c_longlong),
+ .c_ulonglong => Type.initTag(.c_ulonglong),
+ .c_longdouble => Type.initTag(.c_longdouble),
+ .c_void => Type.initTag(.c_void),
+ .f16 => Type.initTag(.f16),
+ .f32 => Type.initTag(.f32),
+ .f64 => Type.initTag(.f64),
+ .f128 => Type.initTag(.f128),
+ .bool => Type.initTag(.bool),
+ .void => Type.initTag(.void),
+ .noreturn => Type.initTag(.noreturn),
+ .type => Type.initTag(.type),
+ .anyerror => Type.initTag(.anyerror),
+ .comptime_int => Type.initTag(.comptime_int),
+ .comptime_float => Type.initTag(.comptime_float),
+ };
+ }
+ };
+ };
+
+ pub const FnType = struct {
+ pub const base_tag = Tag.fntype;
+ base: Inst,
+
+ positionals: struct {
+ param_types: []*Inst,
+ return_type: *Inst,
+ },
+ kw_args: struct {
+ cc: std.builtin.CallingConvention = .Unspecified,
+ },
+ };
+
+ pub const IntCast = struct {
+ pub const base_tag = Tag.intcast;
+ base: Inst,
+
+ positionals: struct {
+ dest_type: *Inst,
+ value: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const BitCast = struct {
+ pub const base_tag = Tag.bitcast;
+ base: Inst,
+
+ positionals: struct {
+ dest_type: *Inst,
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const ElemPtr = struct {
+ pub const base_tag = Tag.elemptr;
+ base: Inst,
+
+ positionals: struct {
+ array_ptr: *Inst,
+ index: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Add = struct {
+ pub const base_tag = Tag.add;
+ base: Inst,
+
+ positionals: struct {
+ lhs: *Inst,
+ rhs: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const Cmp = struct {
+ pub const base_tag = Tag.cmp;
+ base: Inst,
+
+ positionals: struct {
+ lhs: *Inst,
+ op: std.math.CompareOperator,
+ rhs: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const CondBr = struct {
+ pub const base_tag = Tag.condbr;
+ base: Inst,
+
+ positionals: struct {
+ condition: *Inst,
+ true_body: Module.Body,
+ false_body: Module.Body,
+ },
+ kw_args: struct {},
+ };
+
+ pub const IsNull = struct {
+ pub const base_tag = Tag.isnull;
+ base: Inst,
+
+ positionals: struct {
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ pub const IsNonNull = struct {
+ pub const base_tag = Tag.isnonnull;
+ base: Inst,
+
+ positionals: struct {
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+};
+
+pub const ErrorMsg = struct {
+ byte_offset: usize,
+ msg: []const u8,
+};
+
+pub const Module = struct {
+ decls: []*Inst,
+ arena: std.heap.ArenaAllocator,
+ error_msg: ?ErrorMsg = null,
+
+ pub const Body = struct {
+ instructions: []*Inst,
+ };
+
+ pub fn deinit(self: *Module, allocator: *Allocator) void {
+ allocator.free(self.decls);
+ self.arena.deinit();
+ self.* = undefined;
+ }
+
+ /// This is a debugging utility for rendering the tree to stderr.
+ pub fn dump(self: Module) void {
+ self.writeToStream(std.heap.page_allocator, std.io.getStdErr().outStream()) catch {};
+ }
+
+ const InstPtrTable = std.AutoHashMap(*Inst, struct { index: usize, fn_body: ?*Module.Body });
+
+ /// The allocator is used for temporary storage, but this function always returns
+ /// with no resources allocated.
+ pub fn writeToStream(self: Module, allocator: *Allocator, stream: var) !void {
+ // First, build a map of *Inst to @ or % indexes
+ var inst_table = InstPtrTable.init(allocator);
+ defer inst_table.deinit();
+
+ try inst_table.ensureCapacity(self.decls.len);
+
+ for (self.decls) |decl, decl_i| {
+ try inst_table.putNoClobber(decl, .{ .index = decl_i, .fn_body = null });
+
+ if (decl.cast(Inst.Fn)) |fn_inst| {
+ for (fn_inst.positionals.body.instructions) |inst, inst_i| {
+ try inst_table.putNoClobber(inst, .{ .index = inst_i, .fn_body = &fn_inst.positionals.body });
+ }
+ }
+ }
+
+ for (self.decls) |decl, i| {
+ try stream.print("@{} ", .{i});
+ try self.writeInstToStream(stream, decl, &inst_table);
+ try stream.writeByte('\n');
+ }
+ }
+
+ fn writeInstToStream(
+ self: Module,
+ stream: var,
+ decl: *Inst,
+ inst_table: *const InstPtrTable,
+ ) @TypeOf(stream).Error!void {
+ // TODO I tried implementing this with an inline for loop and hit a compiler bug
+ switch (decl.tag) {
+ .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, decl, inst_table),
+ .call => return self.writeInstToStreamGeneric(stream, .call, decl, inst_table),
+ .declref => return self.writeInstToStreamGeneric(stream, .declref, decl, inst_table),
+ .str => return self.writeInstToStreamGeneric(stream, .str, decl, inst_table),
+ .int => return self.writeInstToStreamGeneric(stream, .int, decl, inst_table),
+ .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, decl, inst_table),
+ .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, decl, inst_table),
+ .deref => return self.writeInstToStreamGeneric(stream, .deref, decl, inst_table),
+ .as => return self.writeInstToStreamGeneric(stream, .as, decl, inst_table),
+ .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", decl, inst_table),
+ .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", decl, inst_table),
+ .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", decl, inst_table),
+ .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", decl, inst_table),
+ .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", decl, inst_table),
+ .ref => return self.writeInstToStreamGeneric(stream, .ref, decl, inst_table),
+ .primitive => return self.writeInstToStreamGeneric(stream, .primitive, decl, inst_table),
+ .fntype => return self.writeInstToStreamGeneric(stream, .fntype, decl, inst_table),
+ .intcast => return self.writeInstToStreamGeneric(stream, .intcast, decl, inst_table),
+ .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, decl, inst_table),
+ .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, decl, inst_table),
+ .add => return self.writeInstToStreamGeneric(stream, .add, decl, inst_table),
+ .cmp => return self.writeInstToStreamGeneric(stream, .cmp, decl, inst_table),
+ .condbr => return self.writeInstToStreamGeneric(stream, .condbr, decl, inst_table),
+ .isnull => return self.writeInstToStreamGeneric(stream, .isnull, decl, inst_table),
+ .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, decl, inst_table),
+ }
+ }
+
+ fn writeInstToStreamGeneric(
+ self: Module,
+ stream: var,
+ comptime inst_tag: Inst.Tag,
+ base: *Inst,
+ inst_table: *const InstPtrTable,
+ ) !void {
+ const SpecificInst = Inst.TagToType(inst_tag);
+ const inst = @fieldParentPtr(SpecificInst, "base", base);
+ const Positionals = @TypeOf(inst.positionals);
+ try stream.writeAll("= " ++ @tagName(inst_tag) ++ "(");
+ const pos_fields = @typeInfo(Positionals).Struct.fields;
+ inline for (pos_fields) |arg_field, i| {
+ if (i != 0) {
+ try stream.writeAll(", ");
+ }
+ try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name), inst_table);
+ }
+
+ comptime var need_comma = pos_fields.len != 0;
+ const KW_Args = @TypeOf(inst.kw_args);
+ inline for (@typeInfo(KW_Args).Struct.fields) |arg_field, i| {
+ if (@typeInfo(arg_field.field_type) == .Optional) {
+ if (@field(inst.kw_args, arg_field.name)) |non_optional| {
+ if (need_comma) try stream.writeAll(", ");
+ try stream.print("{}=", .{arg_field.name});
+ try self.writeParamToStream(stream, non_optional, inst_table);
+ need_comma = true;
+ }
+ } else {
+ if (need_comma) try stream.writeAll(", ");
+ try stream.print("{}=", .{arg_field.name});
+ try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name), inst_table);
+ need_comma = true;
+ }
+ }
+
+ try stream.writeByte(')');
+ }
+
+ fn writeParamToStream(self: Module, stream: var, param: var, inst_table: *const InstPtrTable) !void {
+ if (@typeInfo(@TypeOf(param)) == .Enum) {
+ return stream.writeAll(@tagName(param));
+ }
+ switch (@TypeOf(param)) {
+ *Inst => return self.writeInstParamToStream(stream, param, inst_table),
+ []*Inst => {
+ try stream.writeByte('[');
+ for (param) |inst, i| {
+ if (i != 0) {
+ try stream.writeAll(", ");
+ }
+ try self.writeInstParamToStream(stream, inst, inst_table);
+ }
+ try stream.writeByte(']');
+ },
+ Module.Body => {
+ try stream.writeAll("{\n");
+ for (param.instructions) |inst, i| {
+ try stream.print(" %{} ", .{i});
+ try self.writeInstToStream(stream, inst, inst_table);
+ try stream.writeByte('\n');
+ }
+ try stream.writeByte('}');
+ },
+ bool => return stream.writeByte("01"[@boolToInt(param)]),
+ []u8, []const u8 => return std.zig.renderStringLiteral(param, stream),
+ BigIntConst => return stream.print("{}", .{param}),
+ else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
+ }
+ }
+
+ fn writeInstParamToStream(self: Module, stream: var, inst: *Inst, inst_table: *const InstPtrTable) !void {
+ const info = inst_table.getValue(inst).?;
+ const prefix = if (info.fn_body == null) "@" else "%";
+ try stream.print("{}{}", .{ prefix, info.index });
+ }
+};
+
+pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module {
+ var global_name_map = std.StringHashMap(usize).init(allocator);
+ defer global_name_map.deinit();
+
+ var parser: Parser = .{
+ .allocator = allocator,
+ .arena = std.heap.ArenaAllocator.init(allocator),
+ .i = 0,
+ .source = source,
+ .global_name_map = &global_name_map,
+ .decls = .{},
+ .unnamed_index = 0,
+ };
+ errdefer parser.arena.deinit();
+
+ parser.parseRoot() catch |err| switch (err) {
+ error.ParseFailure => {
+ assert(parser.error_msg != null);
+ },
+ else => |e| return e,
+ };
+
+ return Module{
+ .decls = parser.decls.toOwnedSlice(allocator),
+ .arena = parser.arena,
+ .error_msg = parser.error_msg,
+ };
+}
+
+const Parser = struct {
+ allocator: *Allocator,
+ arena: std.heap.ArenaAllocator,
+ i: usize,
+ source: [:0]const u8,
+ decls: std.ArrayListUnmanaged(*Inst),
+ global_name_map: *std.StringHashMap(usize),
+ error_msg: ?ErrorMsg = null,
+ unnamed_index: usize,
+
+ const Body = struct {
+ instructions: std.ArrayList(*Inst),
+ name_map: std.StringHashMap(usize),
+ };
+
+ fn parseBody(self: *Parser) !Module.Body {
+ var body_context = Body{
+ .instructions = std.ArrayList(*Inst).init(self.allocator),
+ .name_map = std.StringHashMap(usize).init(self.allocator),
+ };
+ defer body_context.instructions.deinit();
+ defer body_context.name_map.deinit();
+
+ try requireEatBytes(self, "{");
+ skipSpace(self);
+
+ while (true) : (self.i += 1) switch (self.source[self.i]) {
+ ';' => _ = try skipToAndOver(self, '\n'),
+ '%' => {
+ self.i += 1;
+ const ident = try skipToAndOver(self, ' ');
+ skipSpace(self);
+ try requireEatBytes(self, "=");
+ skipSpace(self);
+ const inst = try parseInstruction(self, &body_context, ident);
+ const ident_index = body_context.instructions.items.len;
+ if (try body_context.name_map.put(ident, ident_index)) |_| {
+ return self.fail("redefinition of identifier '{}'", .{ident});
+ }
+ try body_context.instructions.append(inst);
+ continue;
+ },
+ ' ', '\n' => continue,
+ '}' => {
+ self.i += 1;
+ break;
+ },
+ else => |byte| return self.failByte(byte),
+ };
+
+ // Move the instructions to the arena
+ const instrs = try self.arena.allocator.alloc(*Inst, body_context.instructions.items.len);
+ mem.copy(*Inst, instrs, body_context.instructions.items);
+ return Module.Body{ .instructions = instrs };
+ }
+
+ fn parseStringLiteral(self: *Parser) ![]u8 {
+ const start = self.i;
+ try self.requireEatBytes("\"");
+
+ while (true) : (self.i += 1) switch (self.source[self.i]) {
+ '"' => {
+ self.i += 1;
+ const span = self.source[start..self.i];
+ var bad_index: usize = undefined;
+ const parsed = std.zig.parseStringLiteral(&self.arena.allocator, span, &bad_index) catch |err| switch (err) {
+ error.InvalidCharacter => {
+ self.i = start + bad_index;
+ const bad_byte = self.source[self.i];
+ return self.fail("invalid string literal character: '{c}'\n", .{bad_byte});
+ },
+ else => |e| return e,
+ };
+ return parsed;
+ },
+ '\\' => {
+ self.i += 1;
+ continue;
+ },
+ 0 => return self.failByte(0),
+ else => continue,
+ };
+ }
+
+ fn parseIntegerLiteral(self: *Parser) !BigIntConst {
+ const start = self.i;
+ if (self.source[self.i] == '-') self.i += 1;
+ while (true) : (self.i += 1) switch (self.source[self.i]) {
+ '0'...'9' => continue,
+ else => break,
+ };
+ const number_text = self.source[start..self.i];
+ const base = 10;
+ // TODO reuse the same array list for this
+ const limbs_buffer_len = std.math.big.int.calcSetStringLimbsBufferLen(base, number_text.len);
+ const limbs_buffer = try self.allocator.alloc(std.math.big.Limb, limbs_buffer_len);
+ defer self.allocator.free(limbs_buffer);
+ const limb_len = std.math.big.int.calcSetStringLimbCount(base, number_text.len);
+ const limbs = try self.arena.allocator.alloc(std.math.big.Limb, limb_len);
+ var result = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ result.setString(base, number_text, limbs_buffer, self.allocator) catch |err| switch (err) {
+ error.InvalidCharacter => {
+ self.i = start;
+ return self.fail("invalid digit in integer literal", .{});
+ },
+ };
+ return result.toConst();
+ }
+
+ fn parseRoot(self: *Parser) !void {
+ // The IR format is designed so that it can be tokenized and parsed at the same time.
+ while (true) {
+ switch (self.source[self.i]) {
+ ';' => _ = try skipToAndOver(self, '\n'),
+ '@' => {
+ self.i += 1;
+ const ident = try skipToAndOver(self, ' ');
+ skipSpace(self);
+ try requireEatBytes(self, "=");
+ skipSpace(self);
+ const inst = try parseInstruction(self, null, ident);
+ const ident_index = self.decls.items.len;
+ if (try self.global_name_map.put(ident, ident_index)) |_| {
+ return self.fail("redefinition of identifier '{}'", .{ident});
+ }
+ try self.decls.append(self.allocator, inst);
+ },
+ ' ', '\n' => self.i += 1,
+ 0 => break,
+ else => |byte| return self.fail("unexpected byte: '{c}'", .{byte}),
+ }
+ }
+ }
+
+ fn eatByte(self: *Parser, byte: u8) bool {
+ if (self.source[self.i] != byte) return false;
+ self.i += 1;
+ return true;
+ }
+
+ fn skipSpace(self: *Parser) void {
+ while (self.source[self.i] == ' ' or self.source[self.i] == '\n') {
+ self.i += 1;
+ }
+ }
+
+ fn requireEatBytes(self: *Parser, bytes: []const u8) !void {
+ const start = self.i;
+ for (bytes) |byte| {
+ if (self.source[self.i] != byte) {
+ self.i = start;
+ return self.fail("expected '{}'", .{bytes});
+ }
+ self.i += 1;
+ }
+ }
+
+ fn skipToAndOver(self: *Parser, byte: u8) ![]const u8 {
+ const start_i = self.i;
+ while (self.source[self.i] != 0) : (self.i += 1) {
+ if (self.source[self.i] == byte) {
+ const result = self.source[start_i..self.i];
+ self.i += 1;
+ return result;
+ }
+ }
+ return self.fail("unexpected EOF", .{});
+ }
+
+ /// ParseFailure is an internal error code; handled in `parse`.
+ const InnerError = error{ ParseFailure, OutOfMemory };
+
+ fn failByte(self: *Parser, byte: u8) InnerError {
+ if (byte == 0) {
+ return self.fail("unexpected EOF", .{});
+ } else {
+ return self.fail("unexpected byte: '{c}'", .{byte});
+ }
+ }
+
+ fn fail(self: *Parser, comptime format: []const u8, args: var) InnerError {
+ @setCold(true);
+ self.error_msg = ErrorMsg{
+ .byte_offset = self.i,
+ .msg = try std.fmt.allocPrint(&self.arena.allocator, format, args),
+ };
+ return error.ParseFailure;
+ }
+
+ fn parseInstruction(self: *Parser, body_ctx: ?*Body, name: []const u8) InnerError!*Inst {
+ const contents_start = self.i;
+ const fn_name = try skipToAndOver(self, '(');
+ inline for (@typeInfo(Inst.Tag).Enum.fields) |field| {
+ if (mem.eql(u8, field.name, fn_name)) {
+ const tag = @field(Inst.Tag, field.name);
+ return parseInstructionGeneric(self, field.name, Inst.TagToType(tag), body_ctx, name, contents_start);
+ }
+ }
+ return self.fail("unknown instruction '{}'", .{fn_name});
+ }
+
+ fn parseInstructionGeneric(
+ self: *Parser,
+ comptime fn_name: []const u8,
+ comptime InstType: type,
+ body_ctx: ?*Body,
+ inst_name: []const u8,
+ contents_start: usize,
+ ) InnerError!*Inst {
+ const inst_specific = try self.arena.allocator.create(InstType);
+ inst_specific.base = .{
+ .name = inst_name,
+ .src = self.i,
+ .tag = InstType.base_tag,
+ };
+
+ if (@hasField(InstType, "ty")) {
+ inst_specific.ty = opt_type orelse {
+ return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
+ };
+ }
+
+ const Positionals = @TypeOf(inst_specific.positionals);
+ inline for (@typeInfo(Positionals).Struct.fields) |arg_field| {
+ if (self.source[self.i] == ',') {
+ self.i += 1;
+ skipSpace(self);
+ } else if (self.source[self.i] == ')') {
+ return self.fail("expected positional parameter '{}'", .{arg_field.name});
+ }
+ @field(inst_specific.positionals, arg_field.name) = try parseParameterGeneric(
+ self,
+ arg_field.field_type,
+ body_ctx,
+ );
+ skipSpace(self);
+ }
+
+ const KW_Args = @TypeOf(inst_specific.kw_args);
+ inst_specific.kw_args = .{}; // assign defaults
+ skipSpace(self);
+ while (eatByte(self, ',')) {
+ skipSpace(self);
+ const name = try skipToAndOver(self, '=');
+ inline for (@typeInfo(KW_Args).Struct.fields) |arg_field| {
+ const field_name = arg_field.name;
+ if (mem.eql(u8, name, field_name)) {
+ const NonOptional = switch (@typeInfo(arg_field.field_type)) {
+ .Optional => |info| info.child,
+ else => arg_field.field_type,
+ };
+ @field(inst_specific.kw_args, field_name) = try parseParameterGeneric(self, NonOptional, body_ctx);
+ break;
+ }
+ } else {
+ return self.fail("unrecognized keyword parameter: '{}'", .{name});
+ }
+ skipSpace(self);
+ }
+ try requireEatBytes(self, ")");
+
+ inst_specific.base.contents = self.source[contents_start..self.i];
+
+ return &inst_specific.base;
+ }
+
+ fn parseParameterGeneric(self: *Parser, comptime T: type, body_ctx: ?*Body) !T {
+ if (@typeInfo(T) == .Enum) {
+ const start = self.i;
+ while (true) : (self.i += 1) switch (self.source[self.i]) {
+ ' ', '\n', ',', ')' => {
+ const enum_name = self.source[start..self.i];
+ return std.meta.stringToEnum(T, enum_name) orelse {
+ return self.fail("tag '{}' not a member of enum '{}'", .{ enum_name, @typeName(T) });
+ };
+ },
+ 0 => return self.failByte(0),
+ else => continue,
+ };
+ }
+ switch (T) {
+ Module.Body => return parseBody(self),
+ bool => {
+ const bool_value = switch (self.source[self.i]) {
+ '0' => false,
+ '1' => true,
+ else => |byte| return self.fail("expected '0' or '1' for boolean value, found {c}", .{byte}),
+ };
+ self.i += 1;
+ return bool_value;
+ },
+ []*Inst => {
+ try requireEatBytes(self, "[");
+ skipSpace(self);
+ if (eatByte(self, ']')) return &[0]*Inst{};
+
+ var instructions = std.ArrayList(*Inst).init(&self.arena.allocator);
+ while (true) {
+ skipSpace(self);
+ try instructions.append(try parseParameterInst(self, body_ctx));
+ skipSpace(self);
+ if (!eatByte(self, ',')) break;
+ }
+ try requireEatBytes(self, "]");
+ return instructions.toOwnedSlice();
+ },
+ *Inst => return parseParameterInst(self, body_ctx),
+ []u8, []const u8 => return self.parseStringLiteral(),
+ BigIntConst => return self.parseIntegerLiteral(),
+ else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
+ }
+ return self.fail("TODO parse parameter {}", .{@typeName(T)});
+ }
+
+ fn parseParameterInst(self: *Parser, body_ctx: ?*Body) !*Inst {
+ const local_ref = switch (self.source[self.i]) {
+ '@' => false,
+ '%' => true,
+ else => |byte| return self.fail("unexpected byte: '{c}'", .{byte}),
+ };
+ const map = if (local_ref)
+ if (body_ctx) |bc|
+ &bc.name_map
+ else
+ return self.fail("referencing a % instruction in global scope", .{})
+ else
+ self.global_name_map;
+
+ self.i += 1;
+ const name_start = self.i;
+ while (true) : (self.i += 1) switch (self.source[self.i]) {
+ 0, ' ', '\n', ',', ')', ']' => break,
+ else => continue,
+ };
+ const ident = self.source[name_start..self.i];
+ const kv = map.get(ident) orelse {
+ const bad_name = self.source[name_start - 1 .. self.i];
+ const src = name_start - 1;
+ if (local_ref) {
+ self.i = src;
+ return self.fail("unrecognized identifier: {}", .{bad_name});
+ } else {
+ const name = try self.arena.allocator.create(Inst.Str);
+ name.* = .{
+ .base = .{
+ .name = try self.generateName(),
+ .src = src,
+ .tag = Inst.Str.base_tag,
+ },
+ .positionals = .{ .bytes = ident },
+ .kw_args = .{},
+ };
+ const declref = try self.arena.allocator.create(Inst.DeclRef);
+ declref.* = .{
+ .base = .{
+ .name = try self.generateName(),
+ .src = src,
+ .tag = Inst.DeclRef.base_tag,
+ },
+ .positionals = .{ .name = &name.base },
+ .kw_args = .{},
+ };
+ return &declref.base;
+ }
+ };
+ if (local_ref) {
+ return body_ctx.?.instructions.items[kv.value];
+ } else {
+ return self.decls.items[kv.value];
+ }
+ }
+
+ fn generateName(self: *Parser) ![]u8 {
+ const result = try std.fmt.allocPrint(&self.arena.allocator, "unnamed${}", .{self.unnamed_index});
+ self.unnamed_index += 1;
+ return result;
+ }
+};
+
+pub fn emit(allocator: *Allocator, old_module: IrModule) !Module {
+ var ctx: EmitZIR = .{
+ .allocator = allocator,
+ .decls = .{},
+ .decl_table = std.AutoHashMap(*ir.Inst, *Inst).init(allocator),
+ .arena = std.heap.ArenaAllocator.init(allocator),
+ .old_module = &old_module,
+ };
+ defer ctx.decls.deinit(allocator);
+ defer ctx.decl_table.deinit();
+ errdefer ctx.arena.deinit();
+
+ try ctx.emit();
+
+ return Module{
+ .decls = ctx.decls.toOwnedSlice(allocator),
+ .arena = ctx.arena,
+ };
+}
+
+const EmitZIR = struct {
+ allocator: *Allocator,
+ arena: std.heap.ArenaAllocator,
+ old_module: *const IrModule,
+ decls: std.ArrayListUnmanaged(*Inst),
+ decl_table: std.AutoHashMap(*ir.Inst, *Inst),
+
+ fn emit(self: *EmitZIR) !void {
+ var it = self.old_module.decl_exports.iterator();
+ while (it.next()) |kv| {
+ const decl = kv.key;
+ const exports = kv.value;
+ const export_value = try self.emitTypedValue(decl.src, decl.typed_value.most_recent.typed_value);
+ for (exports) |module_export| {
+ const symbol_name = try self.emitStringLiteral(module_export.src, module_export.options.name);
+ const export_inst = try self.arena.allocator.create(Inst.Export);
+ export_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = module_export.src,
+ .tag = Inst.Export.base_tag,
+ },
+ .positionals = .{
+ .symbol_name = symbol_name,
+ .value = export_value,
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &export_inst.base);
+ }
+ }
+ }
+
+ fn resolveInst(self: *EmitZIR, inst_table: *const std.AutoHashMap(*ir.Inst, *Inst), inst: *ir.Inst) !*Inst {
+ if (inst.cast(ir.Inst.Constant)) |const_inst| {
+ if (self.decl_table.getValue(inst)) |decl| {
+ return decl;
+ }
+ const new_decl = try self.emitTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
+ try self.decl_table.putNoClobber(inst, new_decl);
+ return new_decl;
+ } else {
+ return inst_table.getValue(inst).?;
+ }
+ }
+
+ fn emitComptimeIntVal(self: *EmitZIR, src: usize, val: Value) !*Inst {
+ const big_int_space = try self.arena.allocator.create(Value.BigIntSpace);
+ const int_inst = try self.arena.allocator.create(Inst.Int);
+ int_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.Int.base_tag,
+ },
+ .positionals = .{
+ .int = val.toBigInt(big_int_space),
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &int_inst.base);
+ return &int_inst.base;
+ }
+
+ fn emitTypedValue(self: *EmitZIR, src: usize, typed_value: TypedValue) Allocator.Error!*Inst {
+ const allocator = &self.arena.allocator;
+ switch (typed_value.ty.zigTypeTag()) {
+ .Pointer => {
+ const ptr_elem_type = typed_value.ty.elemType();
+ switch (ptr_elem_type.zigTypeTag()) {
+ .Array => {
+ // TODO more checks to make sure this can be emitted as a string literal
+ //const array_elem_type = ptr_elem_type.elemType();
+ //if (array_elem_type.eql(Type.initTag(.u8)) and
+ // ptr_elem_type.hasSentinel(Value.initTag(.zero)))
+ //{
+ //}
+ const bytes = typed_value.val.toAllocatedBytes(allocator) catch |err| switch (err) {
+ error.AnalysisFail => unreachable,
+ else => |e| return e,
+ };
+ return self.emitStringLiteral(src, bytes);
+ },
+ else => |t| std.debug.panic("TODO implement emitTypedValue for pointer to {}", .{@tagName(t)}),
+ }
+ },
+ .ComptimeInt => return self.emitComptimeIntVal(src, typed_value.val),
+ .Int => {
+ const as_inst = try self.arena.allocator.create(Inst.As);
+ as_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.As.base_tag,
+ },
+ .positionals = .{
+ .dest_type = try self.emitType(src, typed_value.ty),
+ .value = try self.emitComptimeIntVal(src, typed_value.val),
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &as_inst.base);
+
+ return &as_inst.base;
+ },
+ .Type => {
+ const ty = typed_value.val.toType();
+ return self.emitType(src, ty);
+ },
+ .Fn => {
+ const module_fn = typed_value.val.cast(Value.Payload.Function).?.func;
+
+ var inst_table = std.AutoHashMap(*ir.Inst, *Inst).init(self.allocator);
+ defer inst_table.deinit();
+
+ var instructions = std.ArrayList(*Inst).init(self.allocator);
+ defer instructions.deinit();
+
+ try self.emitBody(module_fn.analysis.success, &inst_table, &instructions);
+
+ const fn_type = try self.emitType(src, module_fn.fn_type);
+
+ const arena_instrs = try self.arena.allocator.alloc(*Inst, instructions.items.len);
+ mem.copy(*Inst, arena_instrs, instructions.items);
+
+ const fn_inst = try self.arena.allocator.create(Inst.Fn);
+ fn_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.Fn.base_tag,
+ },
+ .positionals = .{
+ .fn_type = fn_type,
+ .body = .{ .instructions = arena_instrs },
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &fn_inst.base);
+ return &fn_inst.base;
+ },
+ else => |t| std.debug.panic("TODO implement emitTypedValue for {}", .{@tagName(t)}),
+ }
+ }
+
+ fn emitTrivial(self: *EmitZIR, src: usize, comptime T: type) Allocator.Error!*Inst {
+ const new_inst = try self.arena.allocator.create(T);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = T.base_tag,
+ },
+ .positionals = .{},
+ .kw_args = .{},
+ };
+ return &new_inst.base;
+ }
+
+ fn emitBody(
+ self: *EmitZIR,
+ body: IrModule.Body,
+ inst_table: *std.AutoHashMap(*ir.Inst, *Inst),
+ instructions: *std.ArrayList(*Inst),
+ ) Allocator.Error!void {
+ for (body.instructions) |inst| {
+ const new_inst = switch (inst.tag) {
+ .breakpoint => try self.emitTrivial(inst.src, Inst.Breakpoint),
+ .call => blk: {
+ const old_inst = inst.cast(ir.Inst.Call).?;
+ const new_inst = try self.arena.allocator.create(Inst.Call);
+
+ const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
+ for (args) |*elem, i| {
+ elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
+ }
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.Call.base_tag,
+ },
+ .positionals = .{
+ .func = try self.resolveInst(inst_table, old_inst.args.func),
+ .args = args,
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .unreach => try self.emitTrivial(inst.src, Inst.Unreachable),
+ .ret => try self.emitTrivial(inst.src, Inst.Return),
+ .constant => unreachable, // excluded from function bodies
+ .assembly => blk: {
+ const old_inst = inst.cast(ir.Inst.Assembly).?;
+ const new_inst = try self.arena.allocator.create(Inst.Asm);
+
+ const inputs = try self.arena.allocator.alloc(*Inst, old_inst.args.inputs.len);
+ for (inputs) |*elem, i| {
+ elem.* = try self.emitStringLiteral(inst.src, old_inst.args.inputs[i]);
+ }
+
+ const clobbers = try self.arena.allocator.alloc(*Inst, old_inst.args.clobbers.len);
+ for (clobbers) |*elem, i| {
+ elem.* = try self.emitStringLiteral(inst.src, old_inst.args.clobbers[i]);
+ }
+
+ const args = try self.arena.allocator.alloc(*Inst, old_inst.args.args.len);
+ for (args) |*elem, i| {
+ elem.* = try self.resolveInst(inst_table, old_inst.args.args[i]);
+ }
+
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.Asm.base_tag,
+ },
+ .positionals = .{
+ .asm_source = try self.emitStringLiteral(inst.src, old_inst.args.asm_source),
+ .return_type = try self.emitType(inst.src, inst.ty),
+ },
+ .kw_args = .{
+ .@"volatile" = old_inst.args.is_volatile,
+ .output = if (old_inst.args.output) |o|
+ try self.emitStringLiteral(inst.src, o)
+ else
+ null,
+ .inputs = inputs,
+ .clobbers = clobbers,
+ .args = args,
+ },
+ };
+ break :blk &new_inst.base;
+ },
+ .ptrtoint => blk: {
+ const old_inst = inst.cast(ir.Inst.PtrToInt).?;
+ const new_inst = try self.arena.allocator.create(Inst.PtrToInt);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.PtrToInt.base_tag,
+ },
+ .positionals = .{
+ .ptr = try self.resolveInst(inst_table, old_inst.args.ptr),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .bitcast => blk: {
+ const old_inst = inst.cast(ir.Inst.BitCast).?;
+ const new_inst = try self.arena.allocator.create(Inst.BitCast);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.BitCast.base_tag,
+ },
+ .positionals = .{
+ .dest_type = try self.emitType(inst.src, inst.ty),
+ .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .cmp => blk: {
+ const old_inst = inst.cast(ir.Inst.Cmp).?;
+ const new_inst = try self.arena.allocator.create(Inst.Cmp);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.Cmp.base_tag,
+ },
+ .positionals = .{
+ .lhs = try self.resolveInst(inst_table, old_inst.args.lhs),
+ .rhs = try self.resolveInst(inst_table, old_inst.args.rhs),
+ .op = old_inst.args.op,
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .condbr => blk: {
+ const old_inst = inst.cast(ir.Inst.CondBr).?;
+
+ var true_body = std.ArrayList(*Inst).init(self.allocator);
+ var false_body = std.ArrayList(*Inst).init(self.allocator);
+
+ defer true_body.deinit();
+ defer false_body.deinit();
+
+ try self.emitBody(old_inst.args.true_body, inst_table, &true_body);
+ try self.emitBody(old_inst.args.false_body, inst_table, &false_body);
+
+ const new_inst = try self.arena.allocator.create(Inst.CondBr);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.CondBr.base_tag,
+ },
+ .positionals = .{
+ .condition = try self.resolveInst(inst_table, old_inst.args.condition),
+ .true_body = .{ .instructions = true_body.toOwnedSlice() },
+ .false_body = .{ .instructions = false_body.toOwnedSlice() },
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .isnull => blk: {
+ const old_inst = inst.cast(ir.Inst.IsNull).?;
+ const new_inst = try self.arena.allocator.create(Inst.IsNull);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.IsNull.base_tag,
+ },
+ .positionals = .{
+ .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ .isnonnull => blk: {
+ const old_inst = inst.cast(ir.Inst.IsNonNull).?;
+ const new_inst = try self.arena.allocator.create(Inst.IsNonNull);
+ new_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = inst.src,
+ .tag = Inst.IsNonNull.base_tag,
+ },
+ .positionals = .{
+ .operand = try self.resolveInst(inst_table, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
+ };
+ try instructions.append(new_inst);
+ try inst_table.putNoClobber(inst, new_inst);
+ }
+ }
+
+ fn emitType(self: *EmitZIR, src: usize, ty: Type) Allocator.Error!*Inst {
+ switch (ty.tag()) {
+ .isize => return self.emitPrimitiveType(src, .isize),
+ .usize => return self.emitPrimitiveType(src, .usize),
+ .c_short => return self.emitPrimitiveType(src, .c_short),
+ .c_ushort => return self.emitPrimitiveType(src, .c_ushort),
+ .c_int => return self.emitPrimitiveType(src, .c_int),
+ .c_uint => return self.emitPrimitiveType(src, .c_uint),
+ .c_long => return self.emitPrimitiveType(src, .c_long),
+ .c_ulong => return self.emitPrimitiveType(src, .c_ulong),
+ .c_longlong => return self.emitPrimitiveType(src, .c_longlong),
+ .c_ulonglong => return self.emitPrimitiveType(src, .c_ulonglong),
+ .c_longdouble => return self.emitPrimitiveType(src, .c_longdouble),
+ .c_void => return self.emitPrimitiveType(src, .c_void),
+ .f16 => return self.emitPrimitiveType(src, .f16),
+ .f32 => return self.emitPrimitiveType(src, .f32),
+ .f64 => return self.emitPrimitiveType(src, .f64),
+ .f128 => return self.emitPrimitiveType(src, .f128),
+ .anyerror => return self.emitPrimitiveType(src, .anyerror),
+ else => switch (ty.zigTypeTag()) {
+ .Bool => return self.emitPrimitiveType(src, .bool),
+ .Void => return self.emitPrimitiveType(src, .void),
+ .NoReturn => return self.emitPrimitiveType(src, .noreturn),
+ .Type => return self.emitPrimitiveType(src, .type),
+ .ComptimeInt => return self.emitPrimitiveType(src, .comptime_int),
+ .ComptimeFloat => return self.emitPrimitiveType(src, .comptime_float),
+ .Fn => {
+ const param_types = try self.allocator.alloc(Type, ty.fnParamLen());
+ defer self.allocator.free(param_types);
+
+ ty.fnParamTypes(param_types);
+ const emitted_params = try self.arena.allocator.alloc(*Inst, param_types.len);
+ for (param_types) |param_type, i| {
+ emitted_params[i] = try self.emitType(src, param_type);
+ }
+
+ const fntype_inst = try self.arena.allocator.create(Inst.FnType);
+ fntype_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.FnType.base_tag,
+ },
+ .positionals = .{
+ .param_types = emitted_params,
+ .return_type = try self.emitType(src, ty.fnReturnType()),
+ },
+ .kw_args = .{
+ .cc = ty.fnCallingConvention(),
+ },
+ };
+ try self.decls.append(self.allocator, &fntype_inst.base);
+ return &fntype_inst.base;
+ },
+ else => std.debug.panic("TODO implement emitType for {}", .{ty}),
+ },
+ }
+ }
+
+ fn autoName(self: *EmitZIR) ![]u8 {
+ return std.fmt.allocPrint(&self.arena.allocator, "{}", .{self.decls.items.len});
+ }
+
+ fn emitPrimitiveType(self: *EmitZIR, src: usize, tag: Inst.Primitive.BuiltinType) !*Inst {
+ const primitive_inst = try self.arena.allocator.create(Inst.Primitive);
+ primitive_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.Primitive.base_tag,
+ },
+ .positionals = .{
+ .tag = tag,
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &primitive_inst.base);
+ return &primitive_inst.base;
+ }
+
+ fn emitStringLiteral(self: *EmitZIR, src: usize, str: []const u8) !*Inst {
+ const str_inst = try self.arena.allocator.create(Inst.Str);
+ str_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.Str.base_tag,
+ },
+ .positionals = .{
+ .bytes = str,
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &str_inst.base);
+
+ const ref_inst = try self.arena.allocator.create(Inst.Ref);
+ ref_inst.* = .{
+ .base = .{
+ .name = try self.autoName(),
+ .src = src,
+ .tag = Inst.Ref.base_tag,
+ },
+ .positionals = .{
+ .operand = &str_inst.base,
+ },
+ .kw_args = .{},
+ };
+ try self.decls.append(self.allocator, &ref_inst.base);
+
+ return &ref_inst.base;
+ }
+};
