commit a489ea0b2f38c67025c2b2424749a9a7320cdd5a (tree)
parent 0e1c7209e8632ebf398e60de9053e2e0fe8b5661
Author: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 8 Jul 2020 21:03:28 -0700
Merge branch 'register-allocation'
Diffstat:
14 files changed, 1395 insertions(+), 438 deletions(-)
diff --git a/lib/std/array_list.zig b/lib/std/array_list.zig
@@ -257,6 +257,24 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
return &self.items[self.items.len - 1];
}
+ /// Resize the array, adding `n` new elements, which have `undefined` values.
+ /// The return value is an array pointing to the newly allocated elements.
+ pub fn addManyAsArray(self: *Self, comptime n: usize) !*[n]T {
+ const prev_len = self.items.len;
+ try self.resize(self.items.len + n);
+ return self.items[prev_len..][0..n];
+ }
+
+ /// Resize the array, adding `n` new elements, which have `undefined` values.
+ /// The return value is an array pointing to the newly allocated elements.
+ /// Asserts that there is already space for the new item without allocating more.
+ pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {
+ assert(self.items.len + n <= self.capacity);
+ const prev_len = self.items.len;
+ self.items.len += n;
+ return self.items[prev_len..][0..n];
+ }
+
/// Remove and return the last element from the list.
/// Asserts the list has at least one item.
pub fn pop(self: *Self) T {
@@ -488,6 +506,24 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
return &self.items[self.items.len - 1];
}
+ /// Resize the array, adding `n` new elements, which have `undefined` values.
+ /// The return value is an array pointing to the newly allocated elements.
+ pub fn addManyAsArray(self: *Self, allocator: *Allocator, comptime n: usize) !*[n]T {
+ const prev_len = self.items.len;
+ try self.resize(allocator, self.items.len + n);
+ return self.items[prev_len..][0..n];
+ }
+
+ /// Resize the array, adding `n` new elements, which have `undefined` values.
+ /// The return value is an array pointing to the newly allocated elements.
+ /// Asserts that there is already space for the new item without allocating more.
+ pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {
+ assert(self.items.len + n <= self.capacity);
+ const prev_len = self.items.len;
+ self.items.len += n;
+ return self.items[prev_len..][0..n];
+ }
+
/// Remove and return the last element from the list.
/// Asserts the list has at least one item.
/// This operation does not invalidate any element pointers.
@@ -727,3 +763,27 @@ test "std.ArrayList.writer" {
try writer.writeAll("efg");
testing.expectEqualSlices(u8, list.items, "abcdefg");
}
+
+test "addManyAsArray" {
+ const a = std.testing.allocator;
+ {
+ var list = ArrayList(u8).init(a);
+ defer list.deinit();
+
+ (try list.addManyAsArray(4)).* = "aoeu".*;
+ try list.ensureCapacity(8);
+ list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
+
+ testing.expectEqualSlices(u8, list.items, "aoeuasdf");
+ }
+ {
+ var list = ArrayListUnmanaged(u8){};
+ defer list.deinit(a);
+
+ (try list.addManyAsArray(a, 4)).* = "aoeu".*;
+ try list.ensureCapacity(a, 8);
+ list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
+
+ testing.expectEqualSlices(u8, list.items, "aoeuasdf");
+ }
+}
diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig
@@ -15,6 +15,10 @@ pub fn AutoHashMap(comptime K: type, comptime V: type) type {
return HashMap(K, V, getAutoHashFn(K), getAutoEqlFn(K), autoEqlIsCheap(K));
}
+pub fn AutoHashMapUnmanaged(comptime K: type, comptime V: type) type {
+ return HashMapUnmanaged(K, V, getAutoHashFn(K), getAutoEqlFn(K), autoEqlIsCheap(K));
+}
+
/// Builtin hashmap for strings as keys.
pub fn StringHashMap(comptime V: type) type {
return HashMap([]const u8, V, hashString, eqlString, true);
diff --git a/lib/std/math.zig b/lib/std/math.zig
@@ -1047,19 +1047,14 @@ pub fn order(a: var, b: var) Order {
pub const CompareOperator = enum {
/// Less than (`<`)
lt,
-
/// Less than or equal (`<=`)
lte,
-
/// Equal (`==`)
eq,
-
/// Greater than or equal (`>=`)
gte,
-
/// Greater than (`>`)
gt,
-
/// Not equal (`!=`)
neq,
};
diff --git a/lib/std/special/test_runner.zig b/lib/std/special/test_runner.zig
@@ -21,6 +21,7 @@ pub fn main() anyerror!void {
for (test_fn_list) |test_fn, i| {
std.testing.base_allocator_instance.reset();
+ std.testing.log_level = .warn;
var test_node = root_node.start(test_fn.name, null);
test_node.activate();
@@ -73,3 +74,14 @@ pub fn main() anyerror!void {
std.debug.warn("{} passed; {} skipped.\n", .{ ok_count, skip_count });
}
}
+
+pub fn log(
+ comptime message_level: std.log.Level,
+ comptime scope: @Type(.EnumLiteral),
+ comptime format: []const u8,
+ args: var,
+) void {
+ if (@enumToInt(message_level) <= @enumToInt(std.testing.log_level)) {
+ std.debug.print("[{}] ({}): " ++ format, .{@tagName(scope), @tagName(message_level)} ++ args);
+ }
+}
diff --git a/lib/std/std.zig b/lib/std/std.zig
@@ -3,14 +3,16 @@ pub const ArrayListAligned = @import("array_list.zig").ArrayListAligned;
pub const ArrayListAlignedUnmanaged = @import("array_list.zig").ArrayListAlignedUnmanaged;
pub const ArrayListSentineled = @import("array_list_sentineled.zig").ArrayListSentineled;
pub const ArrayListUnmanaged = @import("array_list.zig").ArrayListUnmanaged;
-pub const AutoHashMap = @import("hash_map.zig").AutoHashMap;
+pub const AutoHashMap = hash_map.AutoHashMap;
+pub const AutoHashMapUnmanaged = hash_map.AutoHashMapUnmanaged;
pub const BloomFilter = @import("bloom_filter.zig").BloomFilter;
pub const BufMap = @import("buf_map.zig").BufMap;
pub const BufSet = @import("buf_set.zig").BufSet;
pub const ChildProcess = @import("child_process.zig").ChildProcess;
pub const ComptimeStringMap = @import("comptime_string_map.zig").ComptimeStringMap;
pub const DynLib = @import("dynamic_library.zig").DynLib;
-pub const HashMap = @import("hash_map.zig").HashMap;
+pub const HashMap = hash_map.HashMap;
+pub const HashMapUnmanaged = hash_map.HashMapUnmanaged;
pub const Mutex = @import("mutex.zig").Mutex;
pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
@@ -22,7 +24,7 @@ pub const ResetEvent = @import("reset_event.zig").ResetEvent;
pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
pub const SinglyLinkedList = @import("linked_list.zig").SinglyLinkedList;
pub const SpinLock = @import("spinlock.zig").SpinLock;
-pub const StringHashMap = @import("hash_map.zig").StringHashMap;
+pub const StringHashMap = hash_map.StringHashMap;
pub const TailQueue = @import("linked_list.zig").TailQueue;
pub const Target = @import("target.zig").Target;
pub const Thread = @import("thread.zig").Thread;
diff --git a/lib/std/testing.zig b/lib/std/testing.zig
@@ -14,6 +14,9 @@ pub var failing_allocator_instance = FailingAllocator.init(&base_allocator_insta
pub var base_allocator_instance = std.mem.validationWrap(std.heap.ThreadSafeFixedBufferAllocator.init(allocator_mem[0..]));
var allocator_mem: [2 * 1024 * 1024]u8 = undefined;
+/// TODO https://github.com/ziglang/zig/issues/5738
+pub var log_level = std.log.Level.warn;
+
/// This function is intended to be used only in tests. It prints diagnostics to stderr
/// and then aborts when actual_error_union is not expected_error.
pub fn expectError(expected_error: anyerror, actual_error_union: var) void {
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
@@ -959,6 +959,8 @@ pub const Node = struct {
};
/// The params are directly after the FnProto in memory.
+ /// TODO have a flags field for the optional nodes, and have them appended
+ /// before or after the parameters in memory.
pub const FnProto = struct {
base: Node = Node{ .id = .FnProto },
doc_comments: ?*DocComment,
diff --git a/src-self-hosted/Module.zig b/src-self-hosted/Module.zig
@@ -18,9 +18,10 @@ const Inst = ir.Inst;
const Body = ir.Body;
const ast = std.zig.ast;
const trace = @import("tracy.zig").trace;
+const liveness = @import("liveness.zig");
-/// General-purpose allocator.
-allocator: *Allocator,
+/// General-purpose allocator. Used for both temporary and long-term storage.
+gpa: *Allocator,
/// Pointer to externally managed resource.
root_pkg: *Package,
/// Module owns this resource.
@@ -32,7 +33,7 @@ bin_file_path: []const u8,
/// 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),
+decl_exports: std.AutoHashMapUnmanaged(*Decl, []*Export) = .{},
/// We track which export is associated with the given symbol name for quick
/// detection of symbol collisions.
symbol_exports: std.StringHashMap(*Export),
@@ -40,9 +41,9 @@ symbol_exports: std.StringHashMap(*Export),
/// 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),
+export_owners: std.AutoHashMapUnmanaged(*Decl, []*Export) = .{},
/// Maps fully qualified namespaced names to the Decl struct for them.
-decl_table: DeclTable,
+decl_table: std.HashMapUnmanaged(Scope.NameHash, *Decl, Scope.name_hash_hash, Scope.name_hash_eql, false) = .{},
optimize_mode: std.builtin.Mode,
link_error_flags: link.File.ErrorFlags = .{},
@@ -54,13 +55,13 @@ work_queue: std.fifo.LinearFifo(WorkItem, .Dynamic),
/// 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),
+failed_decls: std.AutoHashMapUnmanaged(*Decl, *ErrorMsg) = .{},
/// Using a map here for consistency with the other fields here.
/// The ErrorMsg memory is owned by the `Scope`, using Module's allocator.
-failed_files: std.AutoHashMap(*Scope, *ErrorMsg),
+failed_files: std.AutoHashMapUnmanaged(*Scope, *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),
+failed_exports: std.AutoHashMapUnmanaged(*Export, *ErrorMsg) = .{},
/// Incrementing integer used to compare against the corresponding Decl
/// field to determine whether a Decl's status applies to an ongoing update, or a
@@ -75,8 +76,6 @@ deletion_set: std.ArrayListUnmanaged(*Decl) = .{},
keep_source_files_loaded: bool,
-const DeclTable = std.HashMap(Scope.NameHash, *Decl, Scope.name_hash_hash, Scope.name_hash_eql, false);
-
const WorkItem = union(enum) {
/// Write the machine code for a Decl to the output file.
codegen_decl: *Decl,
@@ -175,19 +174,23 @@ pub const Decl = struct {
/// The shallow set of other decls whose typed_value could possibly change if this Decl's
/// typed_value is modified.
- dependants: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
+ dependants: DepsTable = .{},
/// The shallow set of other decls whose typed_value changing indicates that this Decl's
/// typed_value may need to be regenerated.
- dependencies: ArrayListUnmanaged(*Decl) = ArrayListUnmanaged(*Decl){},
+ dependencies: DepsTable = .{},
+
+ /// The reason this is not `std.AutoHashMapUnmanaged` is a workaround for
+ /// stage1 compiler giving me: `error: struct 'Module.Decl' depends on itself`
+ pub const DepsTable = std.HashMapUnmanaged(*Decl, void, std.hash_map.getAutoHashFn(*Decl), std.hash_map.getAutoEqlFn(*Decl), false);
- pub fn destroy(self: *Decl, allocator: *Allocator) void {
- allocator.free(mem.spanZ(self.name));
+ pub fn destroy(self: *Decl, gpa: *Allocator) void {
+ gpa.free(mem.spanZ(self.name));
if (self.typedValueManaged()) |tvm| {
- tvm.deinit(allocator);
+ tvm.deinit(gpa);
}
- self.dependants.deinit(allocator);
- self.dependencies.deinit(allocator);
- allocator.destroy(self);
+ self.dependants.deinit(gpa);
+ self.dependencies.deinit(gpa);
+ gpa.destroy(self);
}
pub fn src(self: Decl) usize {
@@ -246,23 +249,11 @@ pub const Decl = struct {
}
fn removeDependant(self: *Decl, other: *Decl) void {
- for (self.dependants.items) |item, i| {
- if (item == other) {
- _ = self.dependants.swapRemove(i);
- return;
- }
- }
- unreachable;
+ self.dependants.removeAssertDiscard(other);
}
fn removeDependency(self: *Decl, other: *Decl) void {
- for (self.dependencies.items) |item, i| {
- if (item == other) {
- _ = self.dependencies.swapRemove(i);
- return;
- }
- }
- unreachable;
+ self.dependencies.removeAssertDiscard(other);
}
};
@@ -312,14 +303,14 @@ pub const Scope = struct {
switch (self.tag) {
.block => return self.cast(Block).?.arena,
.decl => return &self.cast(DeclAnalysis).?.arena.allocator,
- .gen_zir => return &self.cast(GenZIR).?.arena.allocator,
+ .gen_zir => return self.cast(GenZIR).?.arena,
.zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
.file => unreachable,
}
}
- /// Asserts the scope has a parent which is a DeclAnalysis and
- /// returns the Decl.
+ /// If the scope has a parent which is a `DeclAnalysis`,
+ /// returns the `Decl`, otherwise returns `null`.
pub fn decl(self: *Scope) ?*Decl {
return switch (self.tag) {
.block => self.cast(Block).?.decl,
@@ -389,10 +380,10 @@ pub const Scope = struct {
}
}
- pub fn unload(base: *Scope, allocator: *Allocator) void {
+ pub fn unload(base: *Scope, gpa: *Allocator) void {
switch (base.tag) {
- .file => return @fieldParentPtr(File, "base", base).unload(allocator),
- .zir_module => return @fieldParentPtr(ZIRModule, "base", base).unload(allocator),
+ .file => return @fieldParentPtr(File, "base", base).unload(gpa),
+ .zir_module => return @fieldParentPtr(ZIRModule, "base", base).unload(gpa),
.block => unreachable,
.gen_zir => unreachable,
.decl => unreachable,
@@ -421,17 +412,17 @@ pub const Scope = struct {
}
/// Asserts the scope is a File or ZIRModule and deinitializes it, then deallocates it.
- pub fn destroy(base: *Scope, allocator: *Allocator) void {
+ pub fn destroy(base: *Scope, gpa: *Allocator) void {
switch (base.tag) {
.file => {
const scope_file = @fieldParentPtr(File, "base", base);
- scope_file.deinit(allocator);
- allocator.destroy(scope_file);
+ scope_file.deinit(gpa);
+ gpa.destroy(scope_file);
},
.zir_module => {
const scope_zir_module = @fieldParentPtr(ZIRModule, "base", base);
- scope_zir_module.deinit(allocator);
- allocator.destroy(scope_zir_module);
+ scope_zir_module.deinit(gpa);
+ gpa.destroy(scope_zir_module);
},
.block => unreachable,
.gen_zir => unreachable,
@@ -482,7 +473,7 @@ pub const Scope = struct {
/// Direct children of the file.
decls: ArrayListUnmanaged(*Decl),
- pub fn unload(self: *File, allocator: *Allocator) void {
+ pub fn unload(self: *File, gpa: *Allocator) void {
switch (self.status) {
.never_loaded,
.unloaded_parse_failure,
@@ -496,16 +487,16 @@ pub const Scope = struct {
}
switch (self.source) {
.bytes => |bytes| {
- allocator.free(bytes);
+ gpa.free(bytes);
self.source = .{ .unloaded = {} };
},
.unloaded => {},
}
}
- pub fn deinit(self: *File, allocator: *Allocator) void {
- self.decls.deinit(allocator);
- self.unload(allocator);
+ pub fn deinit(self: *File, gpa: *Allocator) void {
+ self.decls.deinit(gpa);
+ self.unload(gpa);
self.* = undefined;
}
@@ -527,7 +518,7 @@ pub const Scope = struct {
switch (self.source) {
.unloaded => {
const source = try module.root_pkg.root_src_dir.readFileAllocOptions(
- module.allocator,
+ module.gpa,
self.sub_file_path,
std.math.maxInt(u32),
1,
@@ -575,7 +566,7 @@ pub const Scope = struct {
/// not this one.
decls: ArrayListUnmanaged(*Decl),
- pub fn unload(self: *ZIRModule, allocator: *Allocator) void {
+ pub fn unload(self: *ZIRModule, gpa: *Allocator) void {
switch (self.status) {
.never_loaded,
.unloaded_parse_failure,
@@ -584,30 +575,30 @@ pub const Scope = struct {
=> {},
.loaded_success => {
- self.contents.module.deinit(allocator);
- allocator.destroy(self.contents.module);
+ self.contents.module.deinit(gpa);
+ gpa.destroy(self.contents.module);
self.contents = .{ .not_available = {} };
self.status = .unloaded_success;
},
.loaded_sema_failure => {
- self.contents.module.deinit(allocator);
- allocator.destroy(self.contents.module);
+ self.contents.module.deinit(gpa);
+ gpa.destroy(self.contents.module);
self.contents = .{ .not_available = {} };
self.status = .unloaded_sema_failure;
},
}
switch (self.source) {
.bytes => |bytes| {
- allocator.free(bytes);
+ gpa.free(bytes);
self.source = .{ .unloaded = {} };
},
.unloaded => {},
}
}
- pub fn deinit(self: *ZIRModule, allocator: *Allocator) void {
- self.decls.deinit(allocator);
- self.unload(allocator);
+ pub fn deinit(self: *ZIRModule, gpa: *Allocator) void {
+ self.decls.deinit(gpa);
+ self.unload(gpa);
self.* = undefined;
}
@@ -629,7 +620,7 @@ pub const Scope = struct {
switch (self.source) {
.unloaded => {
const source = try module.root_pkg.root_src_dir.readFileAllocOptions(
- module.allocator,
+ module.gpa,
self.sub_file_path,
std.math.maxInt(u32),
1,
@@ -662,7 +653,7 @@ pub const Scope = struct {
label: ?Label = null,
pub const Label = struct {
- name: []const u8,
+ zir_block: *zir.Inst.Block,
results: ArrayListUnmanaged(*Inst),
block_inst: *Inst.Block,
};
@@ -683,8 +674,8 @@ pub const Scope = struct {
pub const base_tag: Tag = .gen_zir;
base: Scope = Scope{ .tag = base_tag },
decl: *Decl,
- arena: std.heap.ArenaAllocator,
- instructions: std.ArrayList(*zir.Inst),
+ arena: *Allocator,
+ instructions: std.ArrayListUnmanaged(*zir.Inst) = .{},
};
};
@@ -700,8 +691,8 @@ pub const AllErrors = struct {
msg: []const u8,
};
- pub fn deinit(self: *AllErrors, allocator: *Allocator) void {
- self.arena.promote(allocator).deinit();
+ pub fn deinit(self: *AllErrors, gpa: *Allocator) void {
+ self.arena.promote(gpa).deinit();
}
fn add(
@@ -773,20 +764,14 @@ pub fn init(gpa: *Allocator, options: InitOptions) !Module {
};
return Module{
- .allocator = gpa,
+ .gpa = gpa,
.root_pkg = options.root_pkg,
.root_scope = root_scope,
.bin_file_dir = bin_file_dir,
.bin_file_path = options.bin_file_path,
.bin_file = bin_file,
.optimize_mode = options.optimize_mode,
- .decl_table = DeclTable.init(gpa),
- .decl_exports = std.AutoHashMap(*Decl, []*Export).init(gpa),
.symbol_exports = std.StringHashMap(*Export).init(gpa),
- .export_owners = std.AutoHashMap(*Decl, []*Export).init(gpa),
- .failed_decls = std.AutoHashMap(*Decl, *ErrorMsg).init(gpa),
- .failed_files = std.AutoHashMap(*Scope, *ErrorMsg).init(gpa),
- .failed_exports = std.AutoHashMap(*Export, *ErrorMsg).init(gpa),
.work_queue = std.fifo.LinearFifo(WorkItem, .Dynamic).init(gpa),
.keep_source_files_loaded = options.keep_source_files_loaded,
};
@@ -794,51 +779,51 @@ pub fn init(gpa: *Allocator, options: InitOptions) !Module {
pub fn deinit(self: *Module) void {
self.bin_file.destroy();
- const allocator = self.allocator;
- self.deletion_set.deinit(allocator);
+ const gpa = self.gpa;
+ self.deletion_set.deinit(gpa);
self.work_queue.deinit();
for (self.decl_table.items()) |entry| {
- entry.value.destroy(allocator);
+ entry.value.destroy(gpa);
}
- self.decl_table.deinit();
+ self.decl_table.deinit(gpa);
for (self.failed_decls.items()) |entry| {
- entry.value.destroy(allocator);
+ entry.value.destroy(gpa);
}
- self.failed_decls.deinit();
+ self.failed_decls.deinit(gpa);
for (self.failed_files.items()) |entry| {
- entry.value.destroy(allocator);
+ entry.value.destroy(gpa);
}
- self.failed_files.deinit();
+ self.failed_files.deinit(gpa);
for (self.failed_exports.items()) |entry| {
- entry.value.destroy(allocator);
+ entry.value.destroy(gpa);
}
- self.failed_exports.deinit();
+ self.failed_exports.deinit(gpa);
for (self.decl_exports.items()) |entry| {
const export_list = entry.value;
- allocator.free(export_list);
+ gpa.free(export_list);
}
- self.decl_exports.deinit();
+ self.decl_exports.deinit(gpa);
for (self.export_owners.items()) |entry| {
- freeExportList(allocator, entry.value);
+ freeExportList(gpa, entry.value);
}
- self.export_owners.deinit();
+ self.export_owners.deinit(gpa);
self.symbol_exports.deinit();
- self.root_scope.destroy(allocator);
+ self.root_scope.destroy(gpa);
self.* = undefined;
}
-fn freeExportList(allocator: *Allocator, export_list: []*Export) void {
+fn freeExportList(gpa: *Allocator, export_list: []*Export) void {
for (export_list) |exp| {
- allocator.destroy(exp);
+ gpa.destroy(exp);
}
- allocator.free(export_list);
+ gpa.free(export_list);
}
pub fn target(self: Module) std.Target {
@@ -856,7 +841,7 @@ pub fn update(self: *Module) !void {
// Until then we simulate a full cache miss. Source files could have been loaded for any reason;
// to force a refresh we unload now.
if (self.root_scope.cast(Scope.File)) |zig_file| {
- zig_file.unload(self.allocator);
+ zig_file.unload(self.gpa);
self.analyzeRootSrcFile(zig_file) catch |err| switch (err) {
error.AnalysisFail => {
assert(self.totalErrorCount() != 0);
@@ -864,7 +849,7 @@ pub fn update(self: *Module) !void {
else => |e| return e,
};
} else if (self.root_scope.cast(Scope.ZIRModule)) |zir_module| {
- zir_module.unload(self.allocator);
+ zir_module.unload(self.gpa);
self.analyzeRootZIRModule(zir_module) catch |err| switch (err) {
error.AnalysisFail => {
assert(self.totalErrorCount() != 0);
@@ -877,22 +862,25 @@ pub fn update(self: *Module) !void {
// Process the deletion set.
while (self.deletion_set.popOrNull()) |decl| {
- if (decl.dependants.items.len != 0) {
+ if (decl.dependants.items().len != 0) {
decl.deletion_flag = false;
continue;
}
try self.deleteDecl(decl);
}
+ if (self.totalErrorCount() == 0) {
+ // This is needed before reading the error flags.
+ try self.bin_file.flush();
+ }
+
self.link_error_flags = self.bin_file.errorFlags();
+ std.log.debug(.module, "link_error_flags: {}\n", .{self.link_error_flags});
// If there are any errors, we anticipate the source files being loaded
// to report error messages. Otherwise we unload all source files to save memory.
- if (self.totalErrorCount() == 0) {
- if (!self.keep_source_files_loaded) {
- self.root_scope.unload(self.allocator);
- }
- try self.bin_file.flush();
+ if (self.totalErrorCount() == 0 and !self.keep_source_files_loaded) {
+ self.root_scope.unload(self.gpa);
}
}
@@ -916,10 +904,10 @@ pub fn totalErrorCount(self: *Module) usize {
}
pub fn getAllErrorsAlloc(self: *Module) !AllErrors {
- var arena = std.heap.ArenaAllocator.init(self.allocator);
+ var arena = std.heap.ArenaAllocator.init(self.gpa);
errdefer arena.deinit();
- var errors = std.ArrayList(AllErrors.Message).init(self.allocator);
+ var errors = std.ArrayList(AllErrors.Message).init(self.gpa);
defer errors.deinit();
for (self.failed_files.items()) |entry| {
@@ -988,6 +976,12 @@ pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
.sema_failure, .dependency_failure => continue,
.success => {},
}
+ // Here we tack on additional allocations to the Decl's arena. The allocations are
+ // lifetime annotations in the ZIR.
+ var decl_arena = decl.typed_value.most_recent.arena.?.promote(self.gpa);
+ defer decl.typed_value.most_recent.arena.?.* = decl_arena.state;
+ std.log.debug(.module, "analyze liveness of {}\n", .{decl.name});
+ try liveness.analyze(self.gpa, &decl_arena.allocator, payload.func.analysis.success);
}
assert(decl.typed_value.most_recent.typed_value.ty.hasCodeGenBits());
@@ -998,9 +992,9 @@ pub fn performAllTheWork(self: *Module) error{OutOfMemory}!void {
decl.analysis = .dependency_failure;
},
else => {
- try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
+ try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
- self.allocator,
+ self.gpa,
decl.src(),
"unable to codegen: {}",
.{@errorName(err)},
@@ -1044,16 +1038,17 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
// prior to re-analysis.
self.deleteDeclExports(decl);
// Dependencies will be re-discovered, so we remove them here prior to re-analysis.
- for (decl.dependencies.items) |dep| {
+ for (decl.dependencies.items()) |entry| {
+ const dep = entry.key;
dep.removeDependant(decl);
- if (dep.dependants.items.len == 0 and !dep.deletion_flag) {
+ if (dep.dependants.items().len == 0 and !dep.deletion_flag) {
// We don't perform a deletion here, because this Decl or another one
// may end up referencing it before the update is complete.
dep.deletion_flag = true;
- try self.deletion_set.append(self.allocator, dep);
+ try self.deletion_set.append(self.gpa, dep);
}
}
- decl.dependencies.shrink(self.allocator, 0);
+ decl.dependencies.clearRetainingCapacity();
break :blk true;
},
@@ -1068,9 +1063,9 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
error.OutOfMemory => return error.OutOfMemory,
error.AnalysisFail => return error.AnalysisFail,
else => {
- try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
+ try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
self.failed_decls.putAssumeCapacityNoClobber(decl, try ErrorMsg.create(
- self.allocator,
+ self.gpa,
decl.src(),
"unable to analyze: {}",
.{@errorName(err)},
@@ -1084,7 +1079,8 @@ fn ensureDeclAnalyzed(self: *Module, decl: *Decl) InnerError!void {
// We may need to chase the dependants and re-analyze them.
// However, if the decl is a function, and the type is the same, we do not need to.
if (type_changed or decl.typed_value.most_recent.typed_value.val.tag() != .function) {
- for (decl.dependants.items) |dep| {
+ for (decl.dependants.items()) |entry| {
+ const dep = entry.key;
switch (dep.analysis) {
.unreferenced => unreachable,
.in_progress => unreachable,
@@ -1121,19 +1117,19 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
// This arena allocator's memory is discarded at the end of this function. It is used
// to determine the type of the function, and hence the type of the decl, which is needed
// to complete the Decl analysis.
+ var fn_type_scope_arena = std.heap.ArenaAllocator.init(self.gpa);
+ defer fn_type_scope_arena.deinit();
var fn_type_scope: Scope.GenZIR = .{
.decl = decl,
- .arena = std.heap.ArenaAllocator.init(self.allocator),
- .instructions = std.ArrayList(*zir.Inst).init(self.allocator),
+ .arena = &fn_type_scope_arena.allocator,
};
- defer fn_type_scope.arena.deinit();
- defer fn_type_scope.instructions.deinit();
+ defer fn_type_scope.instructions.deinit(self.gpa);
const body_node = fn_proto.body_node orelse
return self.failTok(&fn_type_scope.base, fn_proto.fn_token, "TODO implement extern functions", .{});
const param_decls = fn_proto.params();
- const param_types = try fn_type_scope.arena.allocator.alloc(*zir.Inst, param_decls.len);
+ const param_types = try fn_type_scope.arena.alloc(*zir.Inst, param_decls.len);
for (param_decls) |param_decl, i| {
const param_type_node = switch (param_decl.param_type) {
.var_type => |node| return self.failNode(&fn_type_scope.base, node, "TODO implement anytype parameter", .{}),
@@ -1174,7 +1170,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
_ = try self.addZIRInst(&fn_type_scope.base, fn_src, zir.Inst.Return, .{ .operand = fn_type_inst }, .{});
// We need the memory for the Type to go into the arena for the Decl
- var decl_arena = std.heap.ArenaAllocator.init(self.allocator);
+ var decl_arena = std.heap.ArenaAllocator.init(self.gpa);
errdefer decl_arena.deinit();
const decl_arena_state = try decl_arena.allocator.create(std.heap.ArenaAllocator.State);
@@ -1185,7 +1181,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
.instructions = .{},
.arena = &decl_arena.allocator,
};
- defer block_scope.instructions.deinit(self.allocator);
+ defer block_scope.instructions.deinit(self.gpa);
const fn_type = try self.analyzeBodyValueAsType(&block_scope, .{
.instructions = fn_type_scope.instructions.items,
@@ -1196,24 +1192,24 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
const fn_zir = blk: {
// This scope's arena memory is discarded after the ZIR generation
// pass completes, and semantic analysis of it completes.
+ var gen_scope_arena = std.heap.ArenaAllocator.init(self.gpa);
+ errdefer gen_scope_arena.deinit();
var gen_scope: Scope.GenZIR = .{
.decl = decl,
- .arena = std.heap.ArenaAllocator.init(self.allocator),
- .instructions = std.ArrayList(*zir.Inst).init(self.allocator),
+ .arena = &gen_scope_arena.allocator,
};
- errdefer gen_scope.arena.deinit();
- defer gen_scope.instructions.deinit();
+ defer gen_scope.instructions.deinit(self.gpa);
const body_block = body_node.cast(ast.Node.Block).?;
try self.astGenBlock(&gen_scope.base, body_block);
- const fn_zir = try gen_scope.arena.allocator.create(Fn.ZIR);
+ const fn_zir = try gen_scope_arena.allocator.create(Fn.ZIR);
fn_zir.* = .{
.body = .{
- .instructions = try gen_scope.arena.allocator.dupe(*zir.Inst, gen_scope.instructions.items),
+ .instructions = try gen_scope.arena.dupe(*zir.Inst, gen_scope.instructions.items),
},
- .arena = gen_scope.arena.state,
+ .arena = gen_scope_arena.state,
};
break :blk fn_zir;
};
@@ -1231,7 +1227,7 @@ fn astGenAndAnalyzeDecl(self: *Module, decl: *Decl) !bool {
prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
type_changed = !tvm.typed_value.ty.eql(fn_type);
- tvm.deinit(self.allocator);
+ tvm.deinit(self.gpa);
}
decl_arena_state.* = decl_arena.state;
@@ -1315,6 +1311,33 @@ fn astGenInfixOp(self: *Module, scope: *Scope, infix_node: *ast.Node.InfixOp) In
return self.addZIRInst(scope, src, zir.Inst.Add, .{ .lhs = lhs, .rhs = rhs }, .{});
},
+ .BangEqual,
+ .EqualEqual,
+ .GreaterThan,
+ .GreaterOrEqual,
+ .LessThan,
+ .LessOrEqual,
+ => {
+ const lhs = try self.astGenExpr(scope, infix_node.lhs);
+ const rhs = try self.astGenExpr(scope, infix_node.rhs);
+
+ const tree = scope.tree();
+ const src = tree.token_locs[infix_node.op_token].start;
+
+ return self.addZIRInst(scope, src, zir.Inst.Cmp, .{
+ .lhs = lhs,
+ .op = @as(std.math.CompareOperator, switch (infix_node.op) {
+ .BangEqual => .neq,
+ .EqualEqual => .eq,
+ .GreaterThan => .gt,
+ .GreaterOrEqual => .gte,
+ .LessThan => .lt,
+ .LessOrEqual => .lte,
+ else => unreachable,
+ }),
+ .rhs = rhs,
+ }, .{});
+ },
else => |op| {
return self.failNode(scope, &infix_node.base, "TODO implement infix operator {}", .{op});
},
@@ -1330,9 +1353,70 @@ fn astGenIf(self: *Module, scope: *Scope, if_node: *ast.Node.If) InnerError!*zir
return self.failNode(scope, payload, "TODO implement astGenIf for error unions", .{});
}
}
- const cond = try self.astGenExpr(scope, if_node.condition);
- const body = try self.astGenExpr(scope, if_node.condition);
- return self.failNode(scope, if_node.condition, "TODO implement astGenIf", .{});
+ var block_scope: Scope.GenZIR = .{
+ .decl = scope.decl().?,
+ .arena = scope.arena(),
+ .instructions = .{},
+ };
+ defer block_scope.instructions.deinit(self.gpa);
+
+ const cond = try self.astGenExpr(&block_scope.base, if_node.condition);
+
+ const tree = scope.tree();
+ const if_src = tree.token_locs[if_node.if_token].start;
+ const condbr = try self.addZIRInstSpecial(&block_scope.base, if_src, zir.Inst.CondBr, .{
+ .condition = cond,
+ .true_body = undefined, // populated below
+ .false_body = undefined, // populated below
+ }, .{});
+
+ const block = try self.addZIRInstBlock(scope, if_src, .{
+ .instructions = try block_scope.arena.dupe(*zir.Inst, block_scope.instructions.items),
+ });
+ var then_scope: Scope.GenZIR = .{
+ .decl = block_scope.decl,
+ .arena = block_scope.arena,
+ .instructions = .{},
+ };
+ defer then_scope.instructions.deinit(self.gpa);
+
+ const then_result = try self.astGenExpr(&then_scope.base, if_node.body);
+ const then_src = tree.token_locs[if_node.body.lastToken()].start;
+ _ = try self.addZIRInst(&then_scope.base, then_src, zir.Inst.Break, .{
+ .block = block,
+ .operand = then_result,
+ }, .{});
+ condbr.positionals.true_body = .{
+ .instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items),
+ };
+
+ var else_scope: Scope.GenZIR = .{
+ .decl = block_scope.decl,
+ .arena = block_scope.arena,
+ .instructions = .{},
+ };
+ defer else_scope.instructions.deinit(self.gpa);
+
+ if (if_node.@"else") |else_node| {
+ const else_result = try self.astGenExpr(&else_scope.base, else_node.body);
+ const else_src = tree.token_locs[else_node.body.lastToken()].start;
+ _ = try self.addZIRInst(&else_scope.base, else_src, zir.Inst.Break, .{
+ .block = block,
+ .operand = else_result,
+ }, .{});
+ } else {
+ // TODO Optimization opportunity: we can avoid an allocation and a memcpy here
+ // by directly allocating the body for this one instruction.
+ const else_src = tree.token_locs[if_node.lastToken()].start;
+ _ = try self.addZIRInst(&else_scope.base, else_src, zir.Inst.BreakVoid, .{
+ .block = block,
+ }, .{});
+ }
+ condbr.positionals.false_body = .{
+ .instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items),
+ };
+
+ return &block.base;
}
fn astGenControlFlowExpression(
@@ -1358,12 +1442,12 @@ fn astGenControlFlowExpression(
fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerError!*zir.Inst {
const tree = scope.tree();
const ident_name = tree.tokenSlice(ident.token);
+ const src = tree.token_locs[ident.token].start;
if (mem.eql(u8, ident_name, "_")) {
return self.failNode(scope, &ident.base, "TODO implement '_' identifier", .{});
}
if (getSimplePrimitiveValue(ident_name)) |typed_value| {
- const src = tree.token_locs[ident.token].start;
return self.addZIRInstConst(scope, src, typed_value);
}
@@ -1387,7 +1471,6 @@ fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerE
64 => if (is_signed) Value.initTag(.i64_type) else Value.initTag(.u64_type),
else => return self.failNode(scope, &ident.base, "TODO implement arbitrary integer bitwidth types", .{}),
};
- const src = tree.token_locs[ident.token].start;
return self.addZIRInstConst(scope, src, .{
.ty = Type.initTag(.type),
.val = val,
@@ -1396,10 +1479,21 @@ fn astGenIdent(self: *Module, scope: *Scope, ident: *ast.Node.Identifier) InnerE
}
if (self.lookupDeclName(scope, ident_name)) |decl| {
- const src = tree.token_locs[ident.token].start;
return try self.addZIRInst(scope, src, zir.Inst.DeclValInModule, .{ .decl = decl }, .{});
}
+ // Function parameter
+ if (scope.decl()) |decl| {
+ if (tree.root_node.decls()[decl.src_index].cast(ast.Node.FnProto)) |fn_proto| {
+ for (fn_proto.params()) |param, i| {
+ const param_name = tree.tokenSlice(param.name_token.?);
+ if (mem.eql(u8, param_name, ident_name)) {
+ return try self.addZIRInst(scope, src, zir.Inst.Arg, .{ .index = i }, .{});
+ }
+ }
+ }
+ }
+
return self.failNode(scope, &ident.base, "TODO implement local variable identifier lookup", .{});
}
@@ -1542,7 +1636,7 @@ fn astGenCall(self: *Module, scope: *Scope, call: *ast.Node.Call) InnerError!*zi
const lhs = try self.astGenExpr(scope, call.lhs);
const param_nodes = call.params();
- const args = try scope.cast(Scope.GenZIR).?.arena.allocator.alloc(*zir.Inst, param_nodes.len);
+ const args = try scope.cast(Scope.GenZIR).?.arena.alloc(*zir.Inst, param_nodes.len);
for (param_nodes) |param_node, i| {
args[i] = try self.astGenExpr(scope, param_node);
}
@@ -1622,40 +1716,31 @@ fn getSimplePrimitiveValue(name: []const u8) ?TypedValue {
}
fn declareDeclDependency(self: *Module, depender: *Decl, dependee: *Decl) !void {
- try depender.dependencies.ensureCapacity(self.allocator, depender.dependencies.items.len + 1);
- try dependee.dependants.ensureCapacity(self.allocator, dependee.dependants.items.len + 1);
+ try depender.dependencies.ensureCapacity(self.gpa, depender.dependencies.items().len + 1);
+ try dependee.dependants.ensureCapacity(self.gpa, dependee.dependants.items().len + 1);
- for (depender.dependencies.items) |item| {
- if (item == dependee) break; // Already in the set.
- } else {
- depender.dependencies.appendAssumeCapacity(dependee);
- }
-
- for (dependee.dependants.items) |item| {
- if (item == depender) break; // Already in the set.
- } else {
- dependee.dependants.appendAssumeCapacity(depender);
- }
+ depender.dependencies.putAssumeCapacity(dependee, {});
+ dependee.dependants.putAssumeCapacity(depender, {});
}
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.items().len + 1);
+ try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
const source = try root_scope.getSource(self);
var keep_zir_module = false;
- const zir_module = try self.allocator.create(zir.Module);
- defer if (!keep_zir_module) self.allocator.destroy(zir_module);
+ const zir_module = try self.gpa.create(zir.Module);
+ defer if (!keep_zir_module) self.gpa.destroy(zir_module);
- zir_module.* = try zir.parse(self.allocator, source);
- defer if (!keep_zir_module) zir_module.deinit(self.allocator);
+ zir_module.* = try zir.parse(self.gpa, source);
+ defer if (!keep_zir_module) zir_module.deinit(self.gpa);
if (zir_module.error_msg) |src_err_msg| {
self.failed_files.putAssumeCapacityNoClobber(
&root_scope.base,
- try ErrorMsg.create(self.allocator, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
+ try ErrorMsg.create(self.gpa, src_err_msg.byte_offset, "{}", .{src_err_msg.msg}),
);
root_scope.status = .unloaded_parse_failure;
return error.AnalysisFail;
@@ -1682,22 +1767,22 @@ fn getAstTree(self: *Module, root_scope: *Scope.File) !*ast.Tree {
switch (root_scope.status) {
.never_loaded, .unloaded_success => {
- try self.failed_files.ensureCapacity(self.failed_files.items().len + 1);
+ try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
const source = try root_scope.getSource(self);
var keep_tree = false;
- const tree = try std.zig.parse(self.allocator, source);
+ const tree = try std.zig.parse(self.gpa, source);
defer if (!keep_tree) tree.deinit();
if (tree.errors.len != 0) {
const parse_err = tree.errors[0];
- var msg = std.ArrayList(u8).init(self.allocator);
+ var msg = std.ArrayList(u8).init(self.gpa);
defer msg.deinit();
try parse_err.render(tree.token_ids, msg.outStream());
- const err_msg = try self.allocator.create(ErrorMsg);
+ const err_msg = try self.gpa.create(ErrorMsg);
err_msg.* = .{
.msg = msg.toOwnedSlice(),
.byte_offset = tree.token_locs[parse_err.loc()].start,
@@ -1728,11 +1813,11 @@ fn analyzeRootSrcFile(self: *Module, root_scope: *Scope.File) !void {
const decls = tree.root_node.decls();
try self.work_queue.ensureUnusedCapacity(decls.len);
- try root_scope.decls.ensureCapacity(self.allocator, decls.len);
+ try root_scope.decls.ensureCapacity(self.gpa, decls.len);
// Keep track of the decls that we expect to see in this file so that
// we know which ones have been deleted.
- var deleted_decls = std.AutoHashMap(*Decl, void).init(self.allocator);
+ var deleted_decls = std.AutoHashMap(*Decl, void).init(self.gpa);
defer deleted_decls.deinit();
try deleted_decls.ensureCapacity(root_scope.decls.items.len);
for (root_scope.decls.items) |file_decl| {
@@ -1756,9 +1841,9 @@ fn analyzeRootSrcFile(self: *Module, root_scope: *Scope.File) !void {
decl.src_index = decl_i;
if (deleted_decls.remove(decl) == null) {
decl.analysis = .sema_failure;
- const err_msg = try ErrorMsg.create(self.allocator, tree.token_locs[name_tok].start, "redefinition of '{}'", .{decl.name});
- errdefer err_msg.destroy(self.allocator);
- try self.failed_decls.putNoClobber(decl, err_msg);
+ const err_msg = try ErrorMsg.create(self.gpa, tree.token_locs[name_tok].start, "redefinition of '{}'", .{decl.name});
+ errdefer err_msg.destroy(self.gpa);
+ try self.failed_decls.putNoClobber(self.gpa, decl, err_msg);
} else {
if (!srcHashEql(decl.contents_hash, contents_hash)) {
try self.markOutdatedDecl(decl);
@@ -1792,14 +1877,14 @@ fn analyzeRootZIRModule(self: *Module, root_scope: *Scope.ZIRModule) !void {
const src_module = try self.getSrcModule(root_scope);
try self.work_queue.ensureUnusedCapacity(src_module.decls.len);
- try root_scope.decls.ensureCapacity(self.allocator, src_module.decls.len);
+ try root_scope.decls.ensureCapacity(self.gpa, src_module.decls.len);
- var exports_to_resolve = std.ArrayList(*zir.Decl).init(self.allocator);
+ var exports_to_resolve = std.ArrayList(*zir.Decl).init(self.gpa);
defer exports_to_resolve.deinit();
// Keep track of the decls that we expect to see in this file so that
// we know which ones have been deleted.
- var deleted_decls = std.AutoHashMap(*Decl, void).init(self.allocator);
+ var deleted_decls = std.AutoHashMap(*Decl, void).init(self.gpa);
defer deleted_decls.deinit();
try deleted_decls.ensureCapacity(self.decl_table.items().len);
for (self.decl_table.items()) |entry| {
@@ -1841,7 +1926,7 @@ fn analyzeRootZIRModule(self: *Module, root_scope: *Scope.ZIRModule) !void {
}
fn deleteDecl(self: *Module, decl: *Decl) !void {
- try self.deletion_set.ensureCapacity(self.allocator, self.deletion_set.items.len + decl.dependencies.items.len);
+ try self.deletion_set.ensureCapacity(self.gpa, self.deletion_set.items.len + decl.dependencies.items().len);
// Remove from the namespace it resides in. In the case of an anonymous Decl it will
// not be present in the set, and this does nothing.
@@ -1851,9 +1936,10 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
const name_hash = decl.fullyQualifiedNameHash();
self.decl_table.removeAssertDiscard(name_hash);
// Remove itself from its dependencies, because we are about to destroy the decl pointer.
- for (decl.dependencies.items) |dep| {
+ for (decl.dependencies.items()) |entry| {
+ const dep = entry.key;
dep.removeDependant(decl);
- if (dep.dependants.items.len == 0 and !dep.deletion_flag) {
+ if (dep.dependants.items().len == 0 and !dep.deletion_flag) {
// We don't recursively perform a deletion here, because during the update,
// another reference to it may turn up.
dep.deletion_flag = true;
@@ -1861,7 +1947,8 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
}
}
// Anything that depends on this deleted decl certainly needs to be re-analyzed.
- for (decl.dependants.items) |dep| {
+ for (decl.dependants.items()) |entry| {
+ const dep = entry.key;
dep.removeDependency(decl);
if (dep.analysis != .outdated) {
// TODO Move this failure possibility to the top of the function.
@@ -1869,11 +1956,11 @@ fn deleteDecl(self: *Module, decl: *Decl) !void {
}
}
if (self.failed_decls.remove(decl)) |entry| {
- entry.value.destroy(self.allocator);
+ entry.value.destroy(self.gpa);
}
self.deleteDeclExports(decl);
self.bin_file.freeDecl(decl);
- decl.destroy(self.allocator);
+ decl.destroy(self.gpa);
}
/// Delete all the Export objects that are caused by this Decl. Re-analysis of
@@ -1895,7 +1982,7 @@ fn deleteDeclExports(self: *Module, decl: *Decl) void {
i += 1;
}
}
- decl_exports_kv.value = self.allocator.shrink(list, new_len);
+ decl_exports_kv.value = self.gpa.shrink(list, new_len);
if (new_len == 0) {
self.decl_exports.removeAssertDiscard(exp.exported_decl);
}
@@ -1904,12 +1991,12 @@ fn deleteDeclExports(self: *Module, decl: *Decl) void {
elf.deleteExport(exp.link);
}
if (self.failed_exports.remove(exp)) |entry| {
- entry.value.destroy(self.allocator);
+ entry.value.destroy(self.gpa);
}
_ = self.symbol_exports.remove(exp.options.name);
- self.allocator.destroy(exp);
+ self.gpa.destroy(exp);
}
- self.allocator.free(kv.value);
+ self.gpa.free(kv.value);
}
fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
@@ -1917,7 +2004,7 @@ fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
defer tracy.end();
// Use the Decl's arena for function memory.
- var arena = decl.typed_value.most_recent.arena.?.promote(self.allocator);
+ var arena = decl.typed_value.most_recent.arena.?.promote(self.gpa);
defer decl.typed_value.most_recent.arena.?.* = arena.state;
var inner_block: Scope.Block = .{
.parent = null,
@@ -1926,10 +2013,10 @@ fn analyzeFnBody(self: *Module, decl: *Decl, func: *Fn) !void {
.instructions = .{},
.arena = &arena.allocator,
};
- defer inner_block.instructions.deinit(self.allocator);
+ defer inner_block.instructions.deinit(self.gpa);
const fn_zir = func.analysis.queued;
- defer fn_zir.arena.promote(self.allocator).deinit();
+ defer fn_zir.arena.promote(self.gpa).deinit();
func.analysis = .{ .in_progress = {} };
//std.debug.warn("set {} to in_progress\n", .{decl.name});
@@ -1944,7 +2031,7 @@ fn markOutdatedDecl(self: *Module, decl: *Decl) !void {
//std.debug.warn("mark {} outdated\n", .{decl.name});
try self.work_queue.writeItem(.{ .analyze_decl = decl });
if (self.failed_decls.remove(decl)) |entry| {
- entry.value.destroy(self.allocator);
+ entry.value.destroy(self.gpa);
}
decl.analysis = .outdated;
}
@@ -1955,7 +2042,7 @@ fn allocateNewDecl(
src_index: usize,
contents_hash: std.zig.SrcHash,
) !*Decl {
- const new_decl = try self.allocator.create(Decl);
+ const new_decl = try self.gpa.create(Decl);
new_decl.* = .{
.name = "",
.scope = scope.namespace(),
@@ -1978,10 +2065,10 @@ fn createNewDecl(
name_hash: Scope.NameHash,
contents_hash: std.zig.SrcHash,
) !*Decl {
- try self.decl_table.ensureCapacity(self.decl_table.items().len + 1);
+ try self.decl_table.ensureCapacity(self.gpa, self.decl_table.items().len + 1);
const new_decl = try self.allocateNewDecl(scope, src_index, contents_hash);
- errdefer self.allocator.destroy(new_decl);
- new_decl.name = try mem.dupeZ(self.allocator, u8, decl_name);
+ errdefer self.gpa.destroy(new_decl);
+ new_decl.name = try mem.dupeZ(self.gpa, u8, decl_name);
self.decl_table.putAssumeCapacityNoClobber(name_hash, new_decl);
return new_decl;
}
@@ -1989,7 +2076,7 @@ fn createNewDecl(
fn analyzeZirDecl(self: *Module, decl: *Decl, src_decl: *zir.Decl) InnerError!bool {
var decl_scope: Scope.DeclAnalysis = .{
.decl = decl,
- .arena = std.heap.ArenaAllocator.init(self.allocator),
+ .arena = std.heap.ArenaAllocator.init(self.gpa),
};
errdefer decl_scope.arena.deinit();
@@ -2005,7 +2092,7 @@ fn analyzeZirDecl(self: *Module, decl: *Decl, src_decl: *zir.Decl) InnerError!bo
prev_type_has_bits = tvm.typed_value.ty.hasCodeGenBits();
type_changed = !tvm.typed_value.ty.eql(typed_value.ty);
- tvm.deinit(self.allocator);
+ tvm.deinit(self.gpa);
}
arena_state.* = decl_scope.arena.state;
@@ -2143,11 +2230,11 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
else => return self.fail(scope, src, "unable to export type '{}'", .{typed_value.ty}),
}
- try self.decl_exports.ensureCapacity(self.decl_exports.items().len + 1);
- try self.export_owners.ensureCapacity(self.export_owners.items().len + 1);
+ try self.decl_exports.ensureCapacity(self.gpa, self.decl_exports.items().len + 1);
+ try self.export_owners.ensureCapacity(self.gpa, self.export_owners.items().len + 1);
- const new_export = try self.allocator.create(Export);
- errdefer self.allocator.destroy(new_export);
+ const new_export = try self.gpa.create(Export);
+ errdefer self.gpa.destroy(new_export);
const owner_decl = scope.decl().?;
@@ -2161,27 +2248,27 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
};
// Add to export_owners table.
- const eo_gop = self.export_owners.getOrPut(owner_decl) catch unreachable;
+ const eo_gop = self.export_owners.getOrPut(self.gpa, owner_decl) catch unreachable;
if (!eo_gop.found_existing) {
eo_gop.entry.value = &[0]*Export{};
}
- eo_gop.entry.value = try self.allocator.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
+ eo_gop.entry.value = try self.gpa.realloc(eo_gop.entry.value, eo_gop.entry.value.len + 1);
eo_gop.entry.value[eo_gop.entry.value.len - 1] = new_export;
- errdefer eo_gop.entry.value = self.allocator.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
+ errdefer eo_gop.entry.value = self.gpa.shrink(eo_gop.entry.value, eo_gop.entry.value.len - 1);
// Add to exported_decl table.
- const de_gop = self.decl_exports.getOrPut(exported_decl) catch unreachable;
+ const de_gop = self.decl_exports.getOrPut(self.gpa, exported_decl) catch unreachable;
if (!de_gop.found_existing) {
de_gop.entry.value = &[0]*Export{};
}
- de_gop.entry.value = try self.allocator.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
+ de_gop.entry.value = try self.gpa.realloc(de_gop.entry.value, de_gop.entry.value.len + 1);
de_gop.entry.value[de_gop.entry.value.len - 1] = new_export;
- errdefer de_gop.entry.value = self.allocator.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
+ errdefer de_gop.entry.value = self.gpa.shrink(de_gop.entry.value, de_gop.entry.value.len - 1);
if (self.symbol_exports.get(symbol_name)) |_| {
- try self.failed_exports.ensureCapacity(self.failed_exports.items().len + 1);
+ try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
- self.allocator,
+ self.gpa,
src,
"exported symbol collision: {}",
.{symbol_name},
@@ -2192,21 +2279,19 @@ fn analyzeExport(self: *Module, scope: *Scope, src: usize, symbol_name: []const
}
try self.symbol_exports.putNoClobber(symbol_name, new_export);
- if (self.bin_file.cast(link.File.Elf)) |elf| {
- elf.updateDeclExports(self, exported_decl, de_gop.entry.value) catch |err| switch (err) {
- error.OutOfMemory => return error.OutOfMemory,
- else => {
- try self.failed_exports.ensureCapacity(self.failed_exports.items().len + 1);
- self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
- self.allocator,
- src,
- "unable to export: {}",
- .{@errorName(err)},
- ));
- new_export.status = .failed_retryable;
- },
- };
- }
+ self.bin_file.updateDeclExports(self, exported_decl, de_gop.entry.value) catch |err| switch (err) {
+ error.OutOfMemory => return error.OutOfMemory,
+ else => {
+ try self.failed_exports.ensureCapacity(self.gpa, self.failed_exports.items().len + 1);
+ self.failed_exports.putAssumeCapacityNoClobber(new_export, try ErrorMsg.create(
+ self.gpa,
+ src,
+ "unable to export: {}",
+ .{@errorName(err)},
+ ));
+ new_export.status = .failed_retryable;
+ },
+ };
}
fn addNewInstArgs(
@@ -2223,13 +2308,13 @@ fn addNewInstArgs(
}
fn newZIRInst(
- allocator: *Allocator,
+ gpa: *Allocator,
src: usize,
comptime T: type,
positionals: std.meta.fieldInfo(T, "positionals").field_type,
kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
-) !*zir.Inst {
- const inst = try allocator.create(T);
+) !*T {
+ const inst = try gpa.create(T);
inst.* = .{
.base = .{
.tag = T.base_tag,
@@ -2238,30 +2323,48 @@ fn newZIRInst(
.positionals = positionals,
.kw_args = kw_args,
};
- return &inst.base;
+ return inst;
}
-fn addZIRInst(
+fn addZIRInstSpecial(
self: *Module,
scope: *Scope,
src: usize,
comptime T: type,
positionals: std.meta.fieldInfo(T, "positionals").field_type,
kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
-) !*zir.Inst {
+) !*T {
const gen_zir = scope.cast(Scope.GenZIR).?;
- try gen_zir.instructions.ensureCapacity(gen_zir.instructions.items.len + 1);
- const inst = try newZIRInst(&gen_zir.arena.allocator, src, T, positionals, kw_args);
- gen_zir.instructions.appendAssumeCapacity(inst);
+ try gen_zir.instructions.ensureCapacity(self.gpa, gen_zir.instructions.items.len + 1);
+ const inst = try newZIRInst(gen_zir.arena, src, T, positionals, kw_args);
+ gen_zir.instructions.appendAssumeCapacity(&inst.base);
return inst;
}
+fn addZIRInst(
+ self: *Module,
+ scope: *Scope,
+ src: usize,
+ comptime T: type,
+ positionals: std.meta.fieldInfo(T, "positionals").field_type,
+ kw_args: std.meta.fieldInfo(T, "kw_args").field_type,
+) !*zir.Inst {
+ const inst_special = try self.addZIRInstSpecial(scope, src, T, positionals, kw_args);
+ return &inst_special.base;
+}
+
/// TODO The existence of this function is a workaround for a bug in stage1.
fn addZIRInstConst(self: *Module, scope: *Scope, src: usize, typed_value: TypedValue) !*zir.Inst {
const P = std.meta.fieldInfo(zir.Inst.Const, "positionals").field_type;
return self.addZIRInst(scope, src, zir.Inst.Const, P{ .typed_value = typed_value }, .{});
}
+/// TODO The existence of this function is a workaround for a bug in stage1.
+fn addZIRInstBlock(self: *Module, scope: *Scope, src: usize, body: zir.Module.Body) !*zir.Inst.Block {
+ const P = std.meta.fieldInfo(zir.Inst.Block, "positionals").field_type;
+ return self.addZIRInstSpecial(scope, src, zir.Inst.Block, P{ .body = body }, .{});
+}
+
fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime T: type) !*T {
const inst = try block.arena.create(T);
inst.* = .{
@@ -2272,7 +2375,7 @@ fn addNewInst(self: *Module, block: *Scope.Block, src: usize, ty: Type, comptime
},
.args = undefined,
};
- try block.instructions.append(self.allocator, &inst.base);
+ try block.instructions.append(self.gpa, &inst.base);
return inst;
}
@@ -2392,6 +2495,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
switch (old_inst.tag) {
.arg => return self.analyzeInstArg(scope, old_inst.cast(zir.Inst.Arg).?),
.block => return self.analyzeInstBlock(scope, old_inst.cast(zir.Inst.Block).?),
+ .@"break" => return self.analyzeInstBreak(scope, old_inst.cast(zir.Inst.Break).?),
.breakpoint => return self.analyzeInstBreakpoint(scope, old_inst.cast(zir.Inst.Breakpoint).?),
.breakvoid => return self.analyzeInstBreakVoid(scope, old_inst.cast(zir.Inst.BreakVoid).?),
.call => return self.analyzeInstCall(scope, old_inst.cast(zir.Inst.Call).?),
@@ -2406,6 +2510,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
const big_int = old_inst.cast(zir.Inst.Int).?.positionals.int;
return self.constIntBig(scope, old_inst.src, Type.initTag(.comptime_int), big_int);
},
+ .inttype => return self.analyzeInstIntType(scope, old_inst.cast(zir.Inst.IntType).?),
.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).?),
@@ -2422,6 +2527,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
.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).?),
+ .sub => return self.analyzeInstSub(scope, old_inst.cast(zir.Inst.Sub).?),
.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).?),
@@ -2432,7 +2538,7 @@ fn analyzeInst(self: *Module, scope: *Scope, old_inst: *zir.Inst) InnerError!*In
fn analyzeInstStr(self: *Module, scope: *Scope, str_inst: *zir.Inst.Str) InnerError!*Inst {
// 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 new anonymous Decl's arena.
- var new_decl_arena = std.heap.ArenaAllocator.init(self.allocator);
+ var new_decl_arena = std.heap.ArenaAllocator.init(self.gpa);
const arena_bytes = try new_decl_arena.allocator.dupe(u8, str_inst.positionals.bytes);
const ty_payload = try scope.arena().create(Type.Payload.Array_u8_Sentinel0);
@@ -2456,8 +2562,8 @@ fn createAnonymousDecl(
) !*Decl {
const name_index = self.getNextAnonNameIndex();
const scope_decl = scope.decl().?;
- const name = try std.fmt.allocPrint(self.allocator, "{}__anon_{}", .{ scope_decl.name, name_index });
- defer self.allocator.free(name);
+ const name = try std.fmt.allocPrint(self.gpa, "{}__anon_{}", .{ scope_decl.name, name_index });
+ defer self.gpa.free(name);
const name_hash = scope.namespace().fullyQualifiedNameHash(name);
const src_hash: std.zig.SrcHash = undefined;
const new_decl = try self.createNewDecl(scope, name, scope_decl.src_index, name_hash, src_hash);
@@ -2546,15 +2652,15 @@ fn analyzeInstBlock(self: *Module, scope: *Scope, inst: *zir.Inst.Block) InnerEr
.arena = parent_block.arena,
// TODO @as here is working around a miscompilation compiler bug :(
.label = @as(?Scope.Block.Label, Scope.Block.Label{
- .name = inst.positionals.label,
+ .zir_block = inst,
.results = .{},
.block_inst = block_inst,
}),
};
const label = &child_block.label.?;
- defer child_block.instructions.deinit(self.allocator);
- defer label.results.deinit(self.allocator);
+ defer child_block.instructions.deinit(self.gpa);
+ defer label.results.deinit(self.gpa);
try self.analyzeBody(&child_block.base, inst.positionals.body);
@@ -2562,21 +2668,9 @@ fn analyzeInstBlock(self: *Module, scope: *Scope, inst: *zir.Inst.Block) InnerEr
assert(child_block.instructions.items.len != 0);
assert(child_block.instructions.items[child_block.instructions.items.len - 1].tag.isNoReturn());
- if (label.results.items.len <= 1) {
- // No need to add the Block instruction; we can add the instructions to the parent block directly.
- // Blocks are terminated with a noreturn instruction which we do not want to include.
- const instrs = child_block.instructions.items;
- try parent_block.instructions.appendSlice(self.allocator, instrs[0 .. instrs.len - 1]);
- if (label.results.items.len == 1) {
- return label.results.items[0];
- } else {
- return self.constNoReturn(scope, inst.base.src);
- }
- }
-
// Need to set the type and emit the Block instruction. This allows machine code generation
// to emit a jump instruction to after the block when it encounters the break.
- try parent_block.instructions.append(self.allocator, &block_inst.base);
+ try parent_block.instructions.append(self.gpa, &block_inst.base);
block_inst.base.ty = try self.resolvePeerTypes(scope, label.results.items);
block_inst.args.body = .{ .instructions = try parent_block.arena.dupe(*Inst, child_block.instructions.items) };
return &block_inst.base;
@@ -2587,22 +2681,39 @@ fn analyzeInstBreakpoint(self: *Module, scope: *Scope, inst: *zir.Inst.Breakpoin
return self.addNewInstArgs(b, inst.base.src, Type.initTag(.void), Inst.Breakpoint, {});
}
+fn analyzeInstBreak(self: *Module, scope: *Scope, inst: *zir.Inst.Break) InnerError!*Inst {
+ const operand = try self.resolveInst(scope, inst.positionals.operand);
+ const block = inst.positionals.block;
+ return self.analyzeBreak(scope, inst.base.src, block, operand);
+}
+
fn analyzeInstBreakVoid(self: *Module, scope: *Scope, inst: *zir.Inst.BreakVoid) InnerError!*Inst {
- const label_name = inst.positionals.label;
+ const block = inst.positionals.block;
const void_inst = try self.constVoid(scope, inst.base.src);
+ return self.analyzeBreak(scope, inst.base.src, block, void_inst);
+}
+fn analyzeBreak(
+ self: *Module,
+ scope: *Scope,
+ src: usize,
+ zir_block: *zir.Inst.Block,
+ operand: *Inst,
+) InnerError!*Inst {
var opt_block = scope.cast(Scope.Block);
while (opt_block) |block| {
if (block.label) |*label| {
- if (mem.eql(u8, label.name, label_name)) {
- try label.results.append(self.allocator, void_inst);
- return self.constNoReturn(scope, inst.base.src);
+ if (label.zir_block == zir_block) {
+ try label.results.append(self.gpa, operand);
+ const b = try self.requireRuntimeBlock(scope, src);
+ return self.addNewInstArgs(b, src, Type.initTag(.noreturn), Inst.Br, .{
+ .block = label.block_inst,
+ .operand = operand,
+ });
}
}
opt_block = block.parent;
- } else {
- return self.fail(scope, inst.base.src, "use of undeclared label '{}'", .{label_name});
- }
+ } else unreachable;
}
fn analyzeInstDeclRefStr(self: *Module, scope: *Scope, inst: *zir.Inst.DeclRefStr) InnerError!*Inst {
@@ -2718,8 +2829,8 @@ fn analyzeInstCall(self: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerErro
// 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);
+ const fn_param_types = try self.gpa.alloc(Type, fn_params_len);
+ defer self.gpa.free(fn_param_types);
func.ty.fnParamTypes(fn_param_types);
const casted_args = try scope.arena().alloc(*Inst, fn_params_len);
@@ -2738,7 +2849,7 @@ fn analyzeInstCall(self: *Module, scope: *Scope, inst: *zir.Inst.Call) InnerErro
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 fn_zir = blk: {
- var fn_arena = std.heap.ArenaAllocator.init(self.allocator);
+ var fn_arena = std.heap.ArenaAllocator.init(self.gpa);
errdefer fn_arena.deinit();
const fn_zir = try scope.arena().create(Fn.ZIR);
@@ -2763,6 +2874,10 @@ fn analyzeInstFn(self: *Module, scope: *Scope, fn_inst: *zir.Inst.Fn) InnerError
});
}
+fn analyzeInstIntType(self: *Module, scope: *Scope, inttype: *zir.Inst.IntType) InnerError!*Inst {
+ return self.fail(scope, inttype.base.src, "TODO implement inttype", .{});
+}
+
fn analyzeInstFnType(self: *Module, scope: *Scope, fntype: *zir.Inst.FnType) InnerError!*Inst {
const return_type = try self.resolveType(scope, fntype.positionals.return_type);
@@ -2923,6 +3038,10 @@ fn analyzeInstElemPtr(self: *Module, scope: *Scope, inst: *zir.Inst.ElemPtr) Inn
return self.fail(scope, inst.base.src, "TODO implement more analyze elemptr", .{});
}
+fn analyzeInstSub(self: *Module, scope: *Scope, inst: *zir.Inst.Sub) InnerError!*Inst {
+ return self.fail(scope, inst.base.src, "TODO implement analysis of sub", .{});
+}
+
fn analyzeInstAdd(self: *Module, scope: *Scope, inst: *zir.Inst.Add) InnerError!*Inst {
const tracy = trace(@src());
defer tracy.end();
@@ -3119,7 +3238,7 @@ fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *zir.Inst.CondBr) Inner
.instructions = .{},
.arena = parent_block.arena,
};
- defer true_block.instructions.deinit(self.allocator);
+ defer true_block.instructions.deinit(self.gpa);
try self.analyzeBody(&true_block.base, inst.positionals.true_body);
var false_block: Scope.Block = .{
@@ -3129,7 +3248,7 @@ fn analyzeInstCondBr(self: *Module, scope: *Scope, inst: *zir.Inst.CondBr) Inner
.instructions = .{},
.arena = parent_block.arena,
};
- defer false_block.instructions.deinit(self.allocator);
+ defer false_block.instructions.deinit(self.gpa);
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){
@@ -3283,7 +3402,7 @@ fn cmpNumeric(
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);
+ var bigint = try lhs_val.toBigInt(&bigint_space).toManaged(self.gpa);
defer bigint.deinit();
const zcmp = lhs_val.orderAgainstZero();
if (lhs_val.floatHasFraction()) {
@@ -3318,7 +3437,7 @@ fn cmpNumeric(
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);
+ var bigint = try rhs_val.toBigInt(&bigint_space).toManaged(self.gpa);
defer bigint.deinit();
const zcmp = rhs_val.orderAgainstZero();
if (rhs_val.floatHasFraction()) {
@@ -3355,7 +3474,7 @@ fn cmpNumeric(
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);
+ const casted_rhs = try self.coerce(scope, dest_type, rhs);
return self.addNewInstArgs(b, src, Type.initTag(.bool), Inst.Cmp, .{
.lhs = casted_lhs,
@@ -3379,6 +3498,8 @@ fn makeIntType(self: *Module, scope: *Scope, signed: bool, bits: u16) !Type {
fn resolvePeerTypes(self: *Module, scope: *Scope, instructions: []*Inst) !Type {
if (instructions.len == 0)
return Type.initTag(.noreturn);
+ if (instructions.len == 1)
+ return instructions[0].ty;
return self.fail(scope, instructions[0].src, "TODO peer type resolution", .{});
}
@@ -3456,7 +3577,7 @@ fn coerceArrayPtrToSlice(self: *Module, scope: *Scope, dest_type: Type, inst: *I
fn fail(self: *Module, scope: *Scope, src: usize, comptime format: []const u8, args: var) InnerError {
@setCold(true);
- const err_msg = try ErrorMsg.create(self.allocator, src, format, args);
+ const err_msg = try ErrorMsg.create(self.gpa, src, format, args);
return self.failWithOwnedErrorMsg(scope, src, err_msg);
}
@@ -3486,9 +3607,9 @@ fn failNode(
fn failWithOwnedErrorMsg(self: *Module, scope: *Scope, src: usize, err_msg: *ErrorMsg) InnerError {
{
- errdefer err_msg.destroy(self.allocator);
- try self.failed_decls.ensureCapacity(self.failed_decls.items().len + 1);
- try self.failed_files.ensureCapacity(self.failed_files.items().len + 1);
+ errdefer err_msg.destroy(self.gpa);
+ try self.failed_decls.ensureCapacity(self.gpa, self.failed_decls.items().len + 1);
+ try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
}
switch (scope.tag) {
.decl => {
@@ -3541,28 +3662,28 @@ 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);
+ pub fn create(gpa: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !*ErrorMsg {
+ const self = try gpa.create(ErrorMsg);
+ errdefer gpa.destroy(self);
+ self.* = try init(gpa, 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 destroy(self: *ErrorMsg, gpa: *Allocator) void {
+ self.deinit(gpa);
+ gpa.destroy(self);
}
- pub fn init(allocator: *Allocator, byte_offset: usize, comptime format: []const u8, args: var) !ErrorMsg {
+ pub fn init(gpa: *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),
+ .msg = try std.fmt.allocPrint(gpa, format, args),
};
}
- pub fn deinit(self: *ErrorMsg, allocator: *Allocator) void {
- allocator.free(self.msg);
+ pub fn deinit(self: *ErrorMsg, gpa: *Allocator) void {
+ gpa.free(self.msg);
self.* = undefined;
}
};
diff --git a/src-self-hosted/codegen.zig b/src-self-hosted/codegen.zig
@@ -12,6 +12,18 @@ const Target = std.Target;
const Allocator = mem.Allocator;
const trace = @import("tracy.zig").trace;
+/// The codegen-related data that is stored in `ir.Inst.Block` instructions.
+pub const BlockData = struct {
+ relocs: std.ArrayListUnmanaged(Reloc) = .{},
+};
+
+pub const Reloc = union(enum) {
+ /// The value is an offset into the `Function` `code` from the beginning.
+ /// To perform the reloc, write 32-bit signed little-endian integer
+ /// which is a relative jump, based on the address following the reloc.
+ rel32: usize,
+};
+
pub const Result = union(enum) {
/// The `code` parameter passed to `generateSymbol` has the value appended.
appended: void,
@@ -46,7 +58,14 @@ pub fn generateSymbol(
var mc_args = try std.ArrayList(Function.MCValue).initCapacity(bin_file.allocator, param_types.len);
defer mc_args.deinit();
- var next_stack_offset: u64 = 0;
+ var branch_stack = std.ArrayList(Function.Branch).init(bin_file.allocator);
+ defer {
+ assert(branch_stack.items.len == 1);
+ branch_stack.items[0].deinit(bin_file.allocator);
+ branch_stack.deinit();
+ }
+ const branch = try branch_stack.addOne();
+ branch.* = .{};
switch (fn_type.fnCallingConvention()) {
.Naked => assert(mc_args.items.len == 0),
@@ -61,8 +80,8 @@ pub fn generateSymbol(
switch (param_type.zigTypeTag()) {
.Bool, .Int => {
if (next_int_reg >= integer_registers.len) {
- try mc_args.append(.{ .stack_offset = next_stack_offset });
- next_stack_offset += param_type.abiSize(bin_file.options.target);
+ try mc_args.append(.{ .stack_offset = branch.next_stack_offset });
+ branch.next_stack_offset += @intCast(u32, param_type.abiSize(bin_file.options.target));
} else {
try mc_args.append(.{ .register = @enumToInt(integer_registers[next_int_reg]) });
next_int_reg += 1;
@@ -100,16 +119,17 @@ pub fn generateSymbol(
}
var function = Function{
+ .gpa = bin_file.allocator,
.target = &bin_file.options.target,
.bin_file = bin_file,
.mod_fn = module_fn,
.code = code,
- .inst_table = std.AutoHashMap(*ir.Inst, Function.MCValue).init(bin_file.allocator),
.err_msg = null,
.args = mc_args.items,
+ .branch_stack = &branch_stack,
};
- defer function.inst_table.deinit();
+ branch.max_end_stack = branch.next_stack_offset;
function.gen() catch |err| switch (err) {
error.CodegenFail => return Result{ .fail = function.err_msg.? },
else => |e| return e,
@@ -210,18 +230,67 @@ pub fn generateSymbol(
}
}
+const InnerError = error {
+ OutOfMemory,
+ CodegenFail,
+};
+
const Function = struct {
+ gpa: *Allocator,
bin_file: *link.File.Elf,
target: *const std.Target,
mod_fn: *const Module.Fn,
code: *std.ArrayList(u8),
- inst_table: std.AutoHashMap(*ir.Inst, MCValue),
err_msg: ?*ErrorMsg,
args: []MCValue,
+ /// Whenever there is a runtime branch, we push a Branch onto this stack,
+ /// and pop it off when the runtime branch joins. This provides an "overlay"
+ /// of the table of mappings from instructions to `MCValue` from within the branch.
+ /// This way we can modify the `MCValue` for an instruction in different ways
+ /// within different branches. Special consideration is needed when a branch
+ /// joins with its parent, to make sure all instructions have the same MCValue
+ /// across each runtime branch upon joining.
+ branch_stack: *std.ArrayList(Branch),
+
+ const Branch = struct {
+ inst_table: std.AutoHashMapUnmanaged(*ir.Inst, MCValue) = .{},
+
+ /// The key is an enum value of an arch-specific register.
+ registers: std.AutoHashMapUnmanaged(usize, RegisterAllocation) = .{},
+
+ /// Maps offset to what is stored there.
+ stack: std.AutoHashMapUnmanaged(usize, StackAllocation) = .{},
+ /// Offset from the stack base, representing the end of the stack frame.
+ max_end_stack: u32 = 0,
+ /// Represents the current end stack offset. If there is no existing slot
+ /// to place a new stack allocation, it goes here, and then bumps `max_end_stack`.
+ next_stack_offset: u32 = 0,
+
+ fn deinit(self: *Branch, gpa: *Allocator) void {
+ self.inst_table.deinit(gpa);
+ self.registers.deinit(gpa);
+ self.stack.deinit(gpa);
+ self.* = undefined;
+ }
+ };
+
+ const RegisterAllocation = struct {
+ inst: *ir.Inst,
+ };
+
+ const StackAllocation = struct {
+ inst: *ir.Inst,
+ size: u32,
+ };
+
const MCValue = union(enum) {
+ /// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.
none,
+ /// Control flow will not allow this value to be observed.
unreach,
+ /// No more references to this value remain.
+ dead,
/// A pointer-sized integer that fits in a register.
immediate: u64,
/// The constant was emitted into the code, at this offset.
@@ -233,6 +302,45 @@ const Function = struct {
memory: u64,
/// The value is one of the stack variables.
stack_offset: u64,
+ /// The value is in the compare flags assuming an unsigned operation,
+ /// with this operator applied on top of it.
+ compare_flags_unsigned: std.math.CompareOperator,
+ /// The value is in the compare flags assuming a signed operation,
+ /// with this operator applied on top of it.
+ compare_flags_signed: std.math.CompareOperator,
+
+ fn isMemory(mcv: MCValue) bool {
+ return switch (mcv) {
+ .embedded_in_code, .memory, .stack_offset => true,
+ else => false,
+ };
+ }
+
+ fn isImmediate(mcv: MCValue) bool {
+ return switch (mcv) {
+ .immediate => true,
+ else => false,
+ };
+ }
+
+ fn isMutable(mcv: MCValue) bool {
+ return switch (mcv) {
+ .none => unreachable,
+ .unreach => unreachable,
+ .dead => unreachable,
+
+ .immediate,
+ .embedded_in_code,
+ .memory,
+ .compare_flags_unsigned,
+ .compare_flags_signed,
+ => false,
+
+ .register,
+ .stack_offset,
+ => true,
+ };
+ }
};
fn gen(self: *Function) !void {
@@ -292,9 +400,14 @@ const Function = struct {
}
fn genArch(self: *Function, comptime arch: std.Target.Cpu.Arch) !void {
- for (self.mod_fn.analysis.success.instructions) |inst| {
+ return self.genBody(self.mod_fn.analysis.success, arch);
+ }
+
+ fn genBody(self: *Function, body: ir.Body, comptime arch: std.Target.Cpu.Arch) InnerError!void {
+ const inst_table = &self.branch_stack.items[0].inst_table;
+ for (body.instructions) |inst| {
const new_inst = try self.genFuncInst(inst, arch);
- try self.inst_table.putNoClobber(inst, new_inst);
+ try inst_table.putNoClobber(self.gpa, inst, new_inst);
}
}
@@ -302,39 +415,166 @@ const Function = struct {
switch (inst.tag) {
.add => return self.genAdd(inst.cast(ir.Inst.Add).?, arch),
.arg => return self.genArg(inst.cast(ir.Inst.Arg).?),
+ .assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?, arch),
+ .bitcast => return self.genBitCast(inst.cast(ir.Inst.BitCast).?),
.block => return self.genBlock(inst.cast(ir.Inst.Block).?, arch),
+ .br => return self.genBr(inst.cast(ir.Inst.Br).?, arch),
.breakpoint => return self.genBreakpoint(inst.src, arch),
+ .brvoid => return self.genBrVoid(inst.cast(ir.Inst.BrVoid).?, arch),
.call => return self.genCall(inst.cast(ir.Inst.Call).?, arch),
- .unreach => return MCValue{ .unreach = {} },
+ .cmp => return self.genCmp(inst.cast(ir.Inst.Cmp).?, arch),
+ .condbr => return self.genCondBr(inst.cast(ir.Inst.CondBr).?, arch),
.constant => unreachable, // excluded from function bodies
- .assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?, arch),
+ .isnonnull => return self.genIsNonNull(inst.cast(ir.Inst.IsNonNull).?, arch),
+ .isnull => return self.genIsNull(inst.cast(ir.Inst.IsNull).?, arch),
.ptrtoint => return self.genPtrToInt(inst.cast(ir.Inst.PtrToInt).?),
- .bitcast => return self.genBitCast(inst.cast(ir.Inst.BitCast).?),
.ret => return self.genRet(inst.cast(ir.Inst.Ret).?, arch),
.retvoid => return self.genRetVoid(inst.cast(ir.Inst.RetVoid).?, arch),
- .cmp => return self.genCmp(inst.cast(ir.Inst.Cmp).?, arch),
- .condbr => return self.genCondBr(inst.cast(ir.Inst.CondBr).?, arch),
- .isnull => return self.genIsNull(inst.cast(ir.Inst.IsNull).?, arch),
- .isnonnull => return self.genIsNonNull(inst.cast(ir.Inst.IsNonNull).?, arch),
+ .sub => return self.genSub(inst.cast(ir.Inst.Sub).?, arch),
+ .unreach => return MCValue{ .unreach = {} },
}
}
fn genAdd(self: *Function, inst: *ir.Inst.Add, comptime arch: std.Target.Cpu.Arch) !MCValue {
- const lhs = try self.resolveInst(inst.args.lhs);
- const rhs = try self.resolveInst(inst.args.rhs);
+ // No side effects, so if it's unreferenced, do nothing.
+ if (inst.base.isUnused())
+ return MCValue.dead;
switch (arch) {
- .i386, .x86_64 => {
- // const lhs_reg = try self.instAsReg(lhs);
- // const rhs_reg = try self.instAsReg(rhs);
- // const result = try self.allocateReg();
+ .x86_64 => {
+ return try self.genX8664BinMath(&inst.base, inst.args.lhs, inst.args.rhs, 0, 0x00);
+ },
+ else => return self.fail(inst.base.src, "TODO implement add for {}", .{self.target.cpu.arch}),
+ }
+ }
- // try self.code.append(??);
+ fn genSub(self: *Function, inst: *ir.Inst.Sub, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ // No side effects, so if it's unreferenced, do nothing.
+ if (inst.base.isUnused())
+ return MCValue.dead;
+ switch (arch) {
+ .x86_64 => {
+ return try self.genX8664BinMath(&inst.base, inst.args.lhs, inst.args.rhs, 5, 0x28);
+ },
+ else => return self.fail(inst.base.src, "TODO implement sub for {}", .{self.target.cpu.arch}),
+ }
+ }
+
+ /// ADD, SUB
+ fn genX8664BinMath(self: *Function, inst: *ir.Inst, op_lhs: *ir.Inst, op_rhs: *ir.Inst, opx: u8, mr: u8) !MCValue {
+ try self.code.ensureCapacity(self.code.items.len + 8);
+
+ const lhs = try self.resolveInst(op_lhs);
+ const rhs = try self.resolveInst(op_rhs);
- // lhs_reg.release();
- // rhs_reg.release();
- return self.fail(inst.base.src, "TODO implement register allocation", .{});
+ // There are 2 operands, destination and source.
+ // Either one, but not both, can be a memory operand.
+ // Source operand can be an immediate, 8 bits or 32 bits.
+ // So, if either one of the operands dies with this instruction, we can use it
+ // as the result MCValue.
+ var dst_mcv: MCValue = undefined;
+ var src_mcv: MCValue = undefined;
+ var src_inst: *ir.Inst = undefined;
+ if (inst.operandDies(0) and lhs.isMutable()) {
+ // LHS dies; use it as the destination.
+ // Both operands cannot be memory.
+ src_inst = op_rhs;
+ if (lhs.isMemory() and rhs.isMemory()) {
+ dst_mcv = try self.copyToNewRegister(op_lhs);
+ src_mcv = rhs;
+ } else {
+ dst_mcv = lhs;
+ src_mcv = rhs;
+ }
+ } else if (inst.operandDies(1) and rhs.isMutable()) {
+ // RHS dies; use it as the destination.
+ // Both operands cannot be memory.
+ src_inst = op_lhs;
+ if (lhs.isMemory() and rhs.isMemory()) {
+ dst_mcv = try self.copyToNewRegister(op_rhs);
+ src_mcv = lhs;
+ } else {
+ dst_mcv = rhs;
+ src_mcv = lhs;
+ }
+ } else {
+ if (lhs.isMemory()) {
+ dst_mcv = try self.copyToNewRegister(op_lhs);
+ src_mcv = rhs;
+ src_inst = op_rhs;
+ } else {
+ dst_mcv = try self.copyToNewRegister(op_rhs);
+ src_mcv = lhs;
+ src_inst = op_lhs;
+ }
+ }
+ // This instruction supports only signed 32-bit immediates at most. If the immediate
+ // value is larger than this, we put it in a register.
+ // A potential opportunity for future optimization here would be keeping track
+ // of the fact that the instruction is available both as an immediate
+ // and as a register.
+ switch (src_mcv) {
+ .immediate => |imm| {
+ if (imm > std.math.maxInt(u31)) {
+ src_mcv = try self.copyToNewRegister(src_inst);
+ }
+ },
+ else => {},
+ }
+
+ try self.genX8664BinMathCode(inst.src, dst_mcv, src_mcv, opx, mr);
+
+ return dst_mcv;
+ }
+
+ fn genX8664BinMathCode(self: *Function, src: usize, dst_mcv: MCValue, src_mcv: MCValue, opx: u8, mr: u8) !void {
+ switch (dst_mcv) {
+ .none => unreachable,
+ .dead, .unreach, .immediate => unreachable,
+ .compare_flags_unsigned => unreachable,
+ .compare_flags_signed => unreachable,
+ .register => |dst_reg_usize| {
+ const dst_reg = @intToEnum(Reg(.x86_64), @intCast(u8, dst_reg_usize));
+ switch (src_mcv) {
+ .none => unreachable,
+ .dead, .unreach => unreachable,
+ .register => |src_reg_usize| {
+ const src_reg = @intToEnum(Reg(.x86_64), @intCast(u8, src_reg_usize));
+ self.rex(.{ .b = dst_reg.isExtended(), .r = src_reg.isExtended(), .w = dst_reg.size() == 64 });
+ self.code.appendSliceAssumeCapacity(&[_]u8{ mr + 0x1, 0xC0 | (@as(u8, src_reg.id() & 0b111) << 3) | @as(u8, dst_reg.id() & 0b111) });
+ },
+ .immediate => |imm| {
+ const imm32 = @intCast(u31, imm); // This case must be handled before calling genX8664BinMathCode.
+ // 81 /opx id
+ if (imm32 <= std.math.maxInt(u7)) {
+ self.rex(.{ .b = dst_reg.isExtended(), .w = dst_reg.size() == 64 });
+ self.code.appendSliceAssumeCapacity(&[_]u8{
+ 0x83,
+ 0xC0 | (opx << 3) | @truncate(u3, dst_reg.id()),
+ @intCast(u8, imm32),
+ });
+ } else {
+ self.rex(.{ .r = dst_reg.isExtended(), .w = dst_reg.size() == 64 });
+ self.code.appendSliceAssumeCapacity(&[_]u8{
+ 0x81,
+ 0xC0 | (opx << 3) | @truncate(u3, dst_reg.id()),
+ });
+ std.mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), imm32);
+ }
+ },
+ .embedded_in_code, .memory, .stack_offset => {
+ return self.fail(src, "TODO implement x86 ADD/SUB/CMP source memory", .{});
+ },
+ .compare_flags_unsigned => {
+ return self.fail(src, "TODO implement x86 ADD/SUB/CMP source compare flag (unsigned)", .{});
+ },
+ .compare_flags_signed => {
+ return self.fail(src, "TODO implement x86 ADD/SUB/CMP source compare flag (signed)", .{});
+ },
+ }
+ },
+ .embedded_in_code, .memory, .stack_offset => {
+ return self.fail(src, "TODO implement x86 ADD/SUB/CMP destination memory", .{});
},
- else => return self.fail(inst.base.src, "TODO implement add for {}", .{self.target.cpu.arch}),
}
}
@@ -410,17 +650,86 @@ const Function = struct {
}
fn genCmp(self: *Function, inst: *ir.Inst.Cmp, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ // No side effects, so if it's unreferenced, do nothing.
+ if (inst.base.isUnused())
+ return MCValue.dead;
switch (arch) {
+ .x86_64 => {
+ try self.code.ensureCapacity(self.code.items.len + 8);
+
+ const lhs = try self.resolveInst(inst.args.lhs);
+ const rhs = try self.resolveInst(inst.args.rhs);
+
+ // There are 2 operands, destination and source.
+ // Either one, but not both, can be a memory operand.
+ // Source operand can be an immediate, 8 bits or 32 bits.
+ const dst_mcv = if (lhs.isImmediate() or (lhs.isMemory() and rhs.isMemory()))
+ try self.copyToNewRegister(inst.args.lhs)
+ else
+ lhs;
+ // This instruction supports only signed 32-bit immediates at most.
+ const src_mcv = try self.limitImmediateType(inst.args.rhs, i32);
+
+ try self.genX8664BinMathCode(inst.base.src, dst_mcv, src_mcv, 7, 0x38);
+ const info = inst.args.lhs.ty.intInfo(self.target.*);
+ if (info.signed) {
+ return MCValue{.compare_flags_signed = inst.args.op};
+ } else {
+ return MCValue{.compare_flags_unsigned = inst.args.op};
+ }
+ },
else => return self.fail(inst.base.src, "TODO implement cmp for {}", .{self.target.cpu.arch}),
}
}
fn genCondBr(self: *Function, inst: *ir.Inst.CondBr, comptime arch: std.Target.Cpu.Arch) !MCValue {
switch (arch) {
+ .i386, .x86_64 => {
+ try self.code.ensureCapacity(self.code.items.len + 6);
+
+ const cond = try self.resolveInst(inst.args.condition);
+ switch (cond) {
+ .compare_flags_signed => |cmp_op| {
+ // Here we map to the opposite opcode because the jump is to the false branch.
+ const opcode: u8 = switch (cmp_op) {
+ .gte => 0x8c,
+ .gt => 0x8e,
+ .neq => 0x84,
+ .lt => 0x8d,
+ .lte => 0x8f,
+ .eq => 0x85,
+ };
+ return self.genX86CondBr(inst, opcode, arch);
+ },
+ .compare_flags_unsigned => |cmp_op| {
+ // Here we map to the opposite opcode because the jump is to the false branch.
+ const opcode: u8 = switch (cmp_op) {
+ .gte => 0x82,
+ .gt => 0x86,
+ .neq => 0x84,
+ .lt => 0x83,
+ .lte => 0x87,
+ .eq => 0x85,
+ };
+ return self.genX86CondBr(inst, opcode, arch);
+ },
+ else => return self.fail(inst.base.src, "TODO implement condbr {} when condition not already in the compare flags", .{self.target.cpu.arch}),
+ }
+ },
else => return self.fail(inst.base.src, "TODO implement condbr for {}", .{self.target.cpu.arch}),
}
}
+ fn genX86CondBr(self: *Function, inst: *ir.Inst.CondBr, opcode: u8, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ self.code.appendSliceAssumeCapacity(&[_]u8{0x0f, opcode});
+ const reloc = Reloc{ .rel32 = self.code.items.len };
+ self.code.items.len += 4;
+ try self.genBody(inst.args.true_body, arch);
+ try self.performReloc(inst.base.src, reloc);
+ try self.genBody(inst.args.false_body, arch);
+ return MCValue.unreach;
+ }
+
fn genIsNull(self: *Function, inst: *ir.Inst.IsNull, comptime arch: std.Target.Cpu.Arch) !MCValue {
switch (arch) {
else => return self.fail(inst.base.src, "TODO implement isnull for {}", .{self.target.cpu.arch}),
@@ -435,29 +744,52 @@ const Function = struct {
}
}
- fn genRelativeFwdJump(self: *Function, src: usize, comptime arch: std.Target.Cpu.Arch, amount: u32) !void {
- switch (arch) {
- .i386, .x86_64 => {
- // TODO x86 treats the operands as signed
- if (amount <= std.math.maxInt(u8)) {
- try self.code.resize(self.code.items.len + 2);
- self.code.items[self.code.items.len - 2] = 0xeb;
- self.code.items[self.code.items.len - 1] = @intCast(u8, amount);
- } else {
- try self.code.resize(self.code.items.len + 5);
- self.code.items[self.code.items.len - 5] = 0xe9; // jmp rel32
- const imm_ptr = self.code.items[self.code.items.len - 4 ..][0..4];
- mem.writeIntLittle(u32, imm_ptr, amount);
- }
+ fn genBlock(self: *Function, inst: *ir.Inst.Block, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ if (inst.base.ty.hasCodeGenBits()) {
+ return self.fail(inst.base.src, "TODO codegen Block with non-void type", .{});
+ }
+ // A block is nothing but a setup to be able to jump to the end.
+ defer inst.codegen.relocs.deinit(self.gpa);
+ try self.genBody(inst.args.body, arch);
+
+ for (inst.codegen.relocs.items) |reloc| try self.performReloc(inst.base.src, reloc);
+
+ return MCValue.none;
+ }
+
+ fn performReloc(self: *Function, src: usize, reloc: Reloc) !void {
+ switch (reloc) {
+ .rel32 => |pos| {
+ const amt = self.code.items.len - (pos + 4);
+ const s32_amt = std.math.cast(i32, amt) catch
+ return self.fail(src, "unable to perform relocation: jump too far", .{});
+ mem.writeIntLittle(i32, self.code.items[pos..][0..4], s32_amt);
},
- else => return self.fail(src, "TODO implement relative forward jump for {}", .{self.target.cpu.arch}),
}
}
- fn genBlock(self: *Function, inst: *ir.Inst.Block, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ fn genBr(self: *Function, inst: *ir.Inst.Br, comptime arch: std.Target.Cpu.Arch) !MCValue {
switch (arch) {
- else => return self.fail(inst.base.src, "TODO implement codegen Block for {}", .{self.target.cpu.arch}),
+ else => return self.fail(inst.base.src, "TODO implement br for {}", .{self.target.cpu.arch}),
+ }
+ }
+
+ fn genBrVoid(self: *Function, inst: *ir.Inst.BrVoid, comptime arch: std.Target.Cpu.Arch) !MCValue {
+ // Emit a jump with a relocation. It will be patched up after the block ends.
+ try inst.args.block.codegen.relocs.ensureCapacity(self.gpa, inst.args.block.codegen.relocs.items.len + 1);
+
+ switch (arch) {
+ .i386, .x86_64 => {
+ // TODO optimization opportunity: figure out when we can emit this as a 2 byte instruction
+ // which is available if the jump is 127 bytes or less forward.
+ try self.code.resize(self.code.items.len + 5);
+ self.code.items[self.code.items.len - 5] = 0xe9; // jmp rel32
+ // Leave the jump offset undefined
+ inst.args.block.codegen.relocs.appendAssumeCapacity(.{ .rel32 = self.code.items.len - 4 });
+ },
+ else => return self.fail(inst.base.src, "TODO implement brvoid for {}", .{self.target.cpu.arch}),
}
+ return .none;
}
fn genAsm(self: *Function, inst: *ir.Inst.Assembly, comptime arch: Target.Cpu.Arch) !MCValue {
@@ -502,30 +834,38 @@ const Function = struct {
/// resulting REX is meaningful, but will remain the same if it is not.
/// * Deliberately inserting a "meaningless REX" requires explicit usage of
/// 0x40, and cannot be done via this function.
- fn REX(self: *Function, arg: struct { B: bool = false, W: bool = false, X: bool = false, R: bool = false }) !void {
+ fn rex(self: *Function, arg: struct { b: bool = false, w: bool = false, x: bool = false, r: bool = false }) void {
// From section 2.2.1.2 of the manual, REX is encoded as b0100WRXB.
var value: u8 = 0x40;
- if (arg.B) {
+ if (arg.b) {
value |= 0x1;
}
- if (arg.X) {
+ if (arg.x) {
value |= 0x2;
}
- if (arg.R) {
+ if (arg.r) {
value |= 0x4;
}
- if (arg.W) {
+ if (arg.w) {
value |= 0x8;
}
if (value != 0x40) {
- try self.code.append(value);
+ self.code.appendAssumeCapacity(value);
}
}
fn genSetReg(self: *Function, src: usize, comptime arch: Target.Cpu.Arch, reg: Reg(arch), mcv: MCValue) error{ CodegenFail, OutOfMemory }!void {
switch (arch) {
.x86_64 => switch (mcv) {
- .none, .unreach => unreachable,
+ .dead => unreachable,
+ .none => unreachable,
+ .unreach => unreachable,
+ .compare_flags_unsigned => |op| {
+ return self.fail(src, "TODO set register with compare flags value (unsigned)", .{});
+ },
+ .compare_flags_signed => |op| {
+ return self.fail(src, "TODO set register with compare flags value (signed)", .{});
+ },
.immediate => |x| {
if (reg.size() != 64) {
return self.fail(src, "TODO decide whether to implement non-64-bit loads", .{});
@@ -544,11 +884,11 @@ const Function = struct {
// If we're accessing e.g. r8d, we need to use a REX prefix before the actual operation. Since
// this is a 32-bit operation, the W flag is set to zero. X is also zero, as we're not using a SIB.
// Both R and B are set, as we're extending, in effect, the register bits *and* the operand.
- try self.REX(.{ .R = reg.isExtended(), .B = reg.isExtended() });
+ try self.code.ensureCapacity(self.code.items.len + 3);
+ self.rex(.{ .r = reg.isExtended(), .b = reg.isExtended() });
const id = @as(u8, reg.id() & 0b111);
- return self.code.appendSlice(&[_]u8{
- 0x31, 0xC0 | id << 3 | id,
- });
+ self.code.appendSliceAssumeCapacity(&[_]u8{ 0x31, 0xC0 | id << 3 | id });
+ return;
}
if (x <= std.math.maxInt(u32)) {
// Next best case: if we set the lower four bytes, the upper four will be zeroed.
@@ -581,9 +921,9 @@ const Function = struct {
// Since we always need a REX here, let's just check if we also need to set REX.B.
//
// In this case, the encoding of the REX byte is 0b0100100B
-
- try self.REX(.{ .W = true, .B = reg.isExtended() });
- try self.code.resize(self.code.items.len + 9);
+ try self.code.ensureCapacity(self.code.items.len + 10);
+ self.rex(.{ .w = true, .b = reg.isExtended() });
+ self.code.items.len += 9;
self.code.items[self.code.items.len - 9] = 0xB8 | @as(u8, reg.id() & 0b111);
const imm_ptr = self.code.items[self.code.items.len - 8 ..][0..8];
mem.writeIntLittle(u64, imm_ptr, x);
@@ -594,13 +934,13 @@ const Function = struct {
}
// We need the offset from RIP in a signed i32 twos complement.
// The instruction is 7 bytes long and RIP points to the next instruction.
- //
+ try self.code.ensureCapacity(self.code.items.len + 7);
// 64-bit LEA is encoded as REX.W 8D /r. If the register is extended, the REX byte is modified,
// but the operation size is unchanged. Since we're using a disp32, we want mode 0 and lower three
// bits as five.
// REX 0x8D 0b00RRR101, where RRR is the lower three bits of the id.
- try self.REX(.{ .W = true, .B = reg.isExtended() });
- try self.code.resize(self.code.items.len + 6);
+ self.rex(.{ .w = true, .b = reg.isExtended() });
+ self.code.items.len += 6;
const rip = self.code.items.len;
const big_offset = @intCast(i64, code_offset) - @intCast(i64, rip);
const offset = @intCast(i32, big_offset);
@@ -620,9 +960,10 @@ const Function = struct {
// If the *source* is extended, the B field must be 1.
// Since the register is being accessed directly, the R/M mode is three. The reg field (the middle
// three bits) contain the destination, and the R/M field (the lower three bits) contain the source.
- try self.REX(.{ .W = true, .R = reg.isExtended(), .B = src_reg.isExtended() });
+ try self.code.ensureCapacity(self.code.items.len + 3);
+ self.rex(.{ .w = true, .r = reg.isExtended(), .b = src_reg.isExtended() });
const R = 0xC0 | (@as(u8, reg.id() & 0b111) << 3) | @as(u8, src_reg.id() & 0b111);
- try self.code.appendSlice(&[_]u8{ 0x8B, R });
+ self.code.appendSliceAssumeCapacity(&[_]u8{ 0x8B, R });
},
.memory => |x| {
if (reg.size() != 64) {
@@ -636,14 +977,14 @@ const Function = struct {
// The SIB must be 0x25, to indicate a disp32 with no scaled index.
// 0b00RRR100, where RRR is the lower three bits of the register ID.
// The instruction is thus eight bytes; REX 0x8B 0b00RRR100 0x25 followed by a four-byte disp32.
- try self.REX(.{ .W = true, .B = reg.isExtended() });
- try self.code.resize(self.code.items.len + 7);
- const r = 0x04 | (@as(u8, reg.id() & 0b111) << 3);
- self.code.items[self.code.items.len - 7] = 0x8B;
- self.code.items[self.code.items.len - 6] = r;
- self.code.items[self.code.items.len - 5] = 0x25;
- const imm_ptr = self.code.items[self.code.items.len - 4 ..][0..4];
- mem.writeIntLittle(u32, imm_ptr, @intCast(u32, x));
+ try self.code.ensureCapacity(self.code.items.len + 8);
+ self.rex(.{ .w = true, .b = reg.isExtended() });
+ self.code.appendSliceAssumeCapacity(&[_]u8{
+ 0x8B,
+ 0x04 | (@as(u8, reg.id() & 0b111) << 3), // R
+ 0x25,
+ });
+ mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), @intCast(u32, x));
} else {
// If this is RAX, we can use a direct load; otherwise, we need to load the address, then indirectly load
// the value.
@@ -674,15 +1015,15 @@ const Function = struct {
// Currently, we're only allowing 64-bit registers, so we need the `REX.W 8B /r` variant.
// TODO: determine whether to allow other sized registers, and if so, handle them properly.
// This operation requires three bytes: REX 0x8B R/M
- //
+ try self.code.ensureCapacity(self.code.items.len + 3);
// For this operation, we want R/M mode *zero* (use register indirectly), and the two register
// values must match. Thus, it's 00ABCABC where ABC is the lower three bits of the register ID.
//
// Furthermore, if this is an extended register, both B and R must be set in the REX byte, as *both*
// register operands need to be marked as extended.
- try self.REX(.{ .W = true, .B = reg.isExtended(), .R = reg.isExtended() });
+ self.rex(.{ .w = true, .b = reg.isExtended(), .r = reg.isExtended() });
const RM = (@as(u8, reg.id() & 0b111) << 3) | @truncate(u3, reg.id());
- try self.code.appendSlice(&[_]u8{ 0x8B, RM });
+ self.code.appendSliceAssumeCapacity(&[_]u8{ 0x8B, RM });
}
}
},
@@ -705,22 +1046,58 @@ const Function = struct {
}
fn resolveInst(self: *Function, inst: *ir.Inst) !MCValue {
- if (self.inst_table.get(inst)) |mcv| {
- return mcv;
- }
+ // Constants have static lifetimes, so they are always memoized in the outer most table.
if (inst.cast(ir.Inst.Constant)) |const_inst| {
- const mcvalue = try self.genTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
- try self.inst_table.putNoClobber(inst, mcvalue);
- return mcvalue;
- } else {
- return self.inst_table.get(inst).?;
+ const branch = &self.branch_stack.items[0];
+ const gop = try branch.inst_table.getOrPut(self.gpa, inst);
+ if (!gop.found_existing) {
+ gop.entry.value = try self.genTypedValue(inst.src, .{ .ty = inst.ty, .val = const_inst.val });
+ }
+ return gop.entry.value;
+ }
+
+ // Treat each stack item as a "layer" on top of the previous one.
+ var i: usize = self.branch_stack.items.len;
+ while (true) {
+ i -= 1;
+ if (self.branch_stack.items[i].inst_table.get(inst)) |mcv| {
+ return mcv;
+ }
}
}
+ fn copyToNewRegister(self: *Function, inst: *ir.Inst) !MCValue {
+ return self.fail(inst.src, "TODO implement copyToNewRegister", .{});
+ }
+
+ /// If the MCValue is an immediate, and it does not fit within this type,
+ /// we put it in a register.
+ /// A potential opportunity for future optimization here would be keeping track
+ /// of the fact that the instruction is available both as an immediate
+ /// and as a register.
+ fn limitImmediateType(self: *Function, inst: *ir.Inst, comptime T: type) !MCValue {
+ const mcv = try self.resolveInst(inst);
+ const ti = @typeInfo(T).Int;
+ switch (mcv) {
+ .immediate => |imm| {
+ // This immediate is unsigned.
+ const U = @Type(.{ .Int = .{
+ .bits = ti.bits - @boolToInt(ti.is_signed),
+ .is_signed = false,
+ }});
+ if (imm >= std.math.maxInt(U)) {
+ return self.copyToNewRegister(inst);
+ }
+ },
+ else => {},
+ }
+ return mcv;
+ }
+
+
fn genTypedValue(self: *Function, src: usize, typed_value: TypedValue) !MCValue {
const ptr_bits = self.target.cpu.arch.ptrBitWidth();
const ptr_bytes: u64 = @divExact(ptr_bits, 8);
- const allocator = self.code.allocator;
switch (typed_value.ty.zigTypeTag()) {
.Pointer => {
if (typed_value.val.cast(Value.Payload.DeclRef)) |payload| {
@@ -747,7 +1124,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 ErrorMsg.create(self.code.allocator, src, format, args);
+ self.err_msg = try ErrorMsg.create(self.bin_file.allocator, src, format, args);
return error.CodegenFail;
}
};
diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig
@@ -2,6 +2,8 @@ const std = @import("std");
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const Module = @import("Module.zig");
+const assert = std.debug.assert;
+const codegen = @import("codegen.zig");
/// These are in-memory, analyzed instructions. See `zir.Inst` for the representation
/// of instructions that correspond to the ZIR text format.
@@ -10,17 +12,43 @@ const Module = @import("Module.zig");
/// a memory location for the value to survive after a const instruction.
pub const Inst = struct {
tag: Tag,
+ /// Each bit represents the index of an `Inst` parameter in the `args` field.
+ /// If a bit is set, it marks the end of the lifetime of the corresponding
+ /// instruction parameter. For example, 0b000_00101 means that the first and
+ /// third `Inst` parameters' lifetimes end after this instruction, and will
+ /// not have any more following references.
+ /// The most significant bit being set means that the instruction itself is
+ /// never referenced, in other words its lifetime ends as soon as it finishes.
+ /// If bit 7 (0b1xxx_xxxx) is set, it means this instruction itself is unreferenced.
+ /// If bit 6 (0bx1xx_xxxx) is set, it means this is a special case and the
+ /// lifetimes of operands are encoded elsewhere.
+ deaths: u8 = undefined,
ty: Type,
/// Byte offset into the source.
src: usize,
+ pub fn isUnused(self: Inst) bool {
+ return (self.deaths & 0b1000_0000) != 0;
+ }
+
+ pub fn operandDies(self: Inst, index: u3) bool {
+ assert(index < 6);
+ return @truncate(u1, self.deaths << index) != 0;
+ }
+
+ pub fn specialOperandDeaths(self: Inst) bool {
+ return (self.deaths & 0b1000_0000) != 0;
+ }
+
pub const Tag = enum {
add,
arg,
assembly,
bitcast,
block,
+ br,
breakpoint,
+ brvoid,
call,
cmp,
condbr,
@@ -30,6 +58,7 @@ pub const Inst = struct {
ptrtoint,
ret,
retvoid,
+ sub,
unreach,
/// Returns whether the instruction is one of the control flow "noreturn" types.
@@ -43,14 +72,17 @@ pub const Inst = struct {
.bitcast,
.block,
.breakpoint,
+ .call,
.cmp,
.constant,
.isnonnull,
.isnull,
.ptrtoint,
- .call,
+ .sub,
=> false,
+ .br,
+ .brvoid,
.condbr,
.ret,
.retvoid,
@@ -128,6 +160,17 @@ pub const Inst = struct {
args: struct {
body: Body,
},
+ /// This memory is reserved for codegen code to do whatever it needs to here.
+ codegen: codegen.BlockData = .{},
+ };
+
+ pub const Br = struct {
+ pub const base_tag = Tag.br;
+ base: Inst,
+ args: struct {
+ block: *Block,
+ operand: *Inst,
+ },
};
pub const Breakpoint = struct {
@@ -136,6 +179,14 @@ pub const Inst = struct {
args: void,
};
+ pub const BrVoid = struct {
+ pub const base_tag = Tag.brvoid;
+ base: Inst,
+ args: struct {
+ block: *Block,
+ },
+ };
+
pub const Call = struct {
pub const base_tag = Tag.call;
base: Inst,
@@ -165,6 +216,12 @@ pub const Inst = struct {
true_body: Body,
false_body: Body,
},
+ /// Set of instructions whose lifetimes end at the start of one of the branches.
+ /// The `true` branch is first: `deaths[0..true_death_count]`.
+ /// The `false` branch is next: `(deaths + true_death_count)[..false_death_count]`.
+ deaths: [*]*Inst = undefined,
+ true_death_count: u32 = 0,
+ false_death_count: u32 = 0,
};
pub const Constant = struct {
@@ -215,6 +272,16 @@ pub const Inst = struct {
args: void,
};
+ pub const Sub = struct {
+ pub const base_tag = Tag.sub;
+ base: Inst,
+
+ args: struct {
+ lhs: *Inst,
+ rhs: *Inst,
+ },
+ };
+
pub const Unreach = struct {
pub const base_tag = Tag.unreach;
base: Inst,
diff --git a/src-self-hosted/link.zig b/src-self-hosted/link.zig
@@ -206,6 +206,19 @@ pub const File = struct {
};
}
+ /// Must be called only after a successful call to `updateDecl`.
+ pub fn updateDeclExports(
+ base: *File,
+ module: *Module,
+ decl: *const Module.Decl,
+ exports: []const *Module.Export,
+ ) !void {
+ switch (base.tag) {
+ .Elf => return @fieldParentPtr(Elf, "base", base).updateDeclExports(module, decl, exports),
+ .C => return {},
+ }
+ }
+
pub const Tag = enum {
Elf,
C,
@@ -248,7 +261,7 @@ pub const File = struct {
pub fn updateDecl(self: *File.C, module: *Module, decl: *Module.Decl) !void {
cgen.generate(self, decl) catch |err| {
if (err == error.CGenFailure) {
- try module.failed_decls.put(decl, self.error_msg);
+ try module.failed_decls.put(module.gpa, decl, self.error_msg);
}
return err;
};
@@ -566,7 +579,7 @@ pub const File = struct {
const file_size = self.options.program_code_size_hint;
const p_align = 0x1000;
const off = self.findFreeSpace(file_size, p_align);
- //std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
try self.program_headers.append(self.allocator, .{
.p_type = elf.PT_LOAD,
.p_offset = off,
@@ -587,7 +600,7 @@ pub const File = struct {
// page align.
const p_align = 0x1000;
const off = self.findFreeSpace(file_size, p_align);
- //std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ std.log.debug(.link, "found PT_LOAD free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
// TODO instead of hard coding the vaddr, make a function to find a vaddr to put things at.
// we'll need to re-use that function anyway, in case the GOT grows and overlaps something
// else in virtual memory.
@@ -609,7 +622,7 @@ pub const File = struct {
assert(self.shstrtab.items.len == 0);
try self.shstrtab.append(self.allocator, 0); // need a 0 at position 0
const off = self.findFreeSpace(self.shstrtab.items.len, 1);
- //std.log.debug(.link, "found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
+ std.log.debug(.link, "found shstrtab free space 0x{x} to 0x{x}\n", .{ off, off + self.shstrtab.items.len });
try self.sections.append(self.allocator, .{
.sh_name = try self.makeString(".shstrtab"),
.sh_type = elf.SHT_STRTAB,
@@ -667,7 +680,7 @@ pub const File = struct {
const each_size: u64 = if (small_ptr) @sizeOf(elf.Elf32_Sym) else @sizeOf(elf.Elf64_Sym);
const file_size = self.options.symbol_count_hint * each_size;
const off = self.findFreeSpace(file_size, min_align);
- //std.log.debug(.link, "found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
+ std.log.debug(.link, "found symtab free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
try self.sections.append(self.allocator, .{
.sh_name = try self.makeString(".symtab"),
@@ -783,7 +796,7 @@ pub const File = struct {
shstrtab_sect.sh_offset = self.findFreeSpace(needed_size, 1);
}
shstrtab_sect.sh_size = needed_size;
- //std.log.debug(.link, "shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
+ std.log.debug(.link, "shstrtab start=0x{x} end=0x{x}\n", .{ shstrtab_sect.sh_offset, shstrtab_sect.sh_offset + needed_size });
try self.file.?.pwriteAll(self.shstrtab.items, shstrtab_sect.sh_offset);
if (!self.shdr_table_dirty) {
@@ -829,7 +842,7 @@ pub const File = struct {
for (buf) |*shdr, i| {
shdr.* = self.sections.items[i];
- //std.log.debug(.link, "writing section {}\n", .{shdr.*});
+ std.log.debug(.link, "writing section {}\n", .{shdr.*});
if (foreign_endian) {
bswapAllFields(elf.Elf64_Shdr, shdr);
}
@@ -840,6 +853,7 @@ pub const File = struct {
self.shdr_table_dirty = false;
}
if (self.entry_addr == null and self.options.output_mode == .Exe) {
+ std.log.debug(.link, "no_entry_point_found = true\n", .{});
self.error_flags.no_entry_point_found = true;
} else {
self.error_flags.no_entry_point_found = false;
@@ -1153,10 +1167,10 @@ pub const File = struct {
try self.offset_table_free_list.ensureCapacity(self.allocator, self.local_symbols.items.len);
if (self.local_symbol_free_list.popOrNull()) |i| {
- //std.log.debug(.link, "reusing symbol index {} for {}\n", .{i, decl.name});
+ std.log.debug(.link, "reusing symbol index {} for {}\n", .{i, decl.name});
decl.link.local_sym_index = i;
} else {
- //std.log.debug(.link, "allocating symbol index {} for {}\n", .{self.local_symbols.items.len, decl.name});
+ std.log.debug(.link, "allocating symbol index {} for {}\n", .{self.local_symbols.items.len, decl.name});
decl.link.local_sym_index = @intCast(u32, self.local_symbols.items.len);
_ = self.local_symbols.addOneAssumeCapacity();
}
@@ -1204,7 +1218,7 @@ pub const File = struct {
.appended => code_buffer.items,
.fail => |em| {
decl.analysis = .codegen_failure;
- try module.failed_decls.put(decl, em);
+ try module.failed_decls.put(module.gpa, decl, em);
return;
},
};
@@ -1224,11 +1238,11 @@ pub const File = struct {
!mem.isAlignedGeneric(u64, local_sym.st_value, required_alignment);
if (need_realloc) {
const vaddr = try self.growTextBlock(&decl.link, code.len, required_alignment);
- //std.log.debug(.link, "growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });
+ std.log.debug(.link, "growing {} from 0x{x} to 0x{x}\n", .{ decl.name, local_sym.st_value, vaddr });
if (vaddr != local_sym.st_value) {
local_sym.st_value = vaddr;
- //std.log.debug(.link, " (writing new offset table entry)\n", .{});
+ std.log.debug(.link, " (writing new offset table entry)\n", .{});
self.offset_table.items[decl.link.offset_table_index] = vaddr;
try self.writeOffsetTableEntry(decl.link.offset_table_index);
}
@@ -1246,7 +1260,7 @@ pub const File = struct {
const decl_name = mem.spanZ(decl.name);
const name_str_index = try self.makeString(decl_name);
const vaddr = try self.allocateTextBlock(&decl.link, code.len, required_alignment);
- //std.log.debug(.link, "allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });
+ std.log.debug(.link, "allocated text block for {} at 0x{x}\n", .{ decl_name, vaddr });
errdefer self.freeTextBlock(&decl.link);
local_sym.* = .{
@@ -1290,7 +1304,7 @@ pub const File = struct {
for (exports) |exp| {
if (exp.options.section) |section_name| {
if (!mem.eql(u8, section_name, ".text")) {
- try module.failed_exports.ensureCapacity(module.failed_exports.items().len + 1);
+ try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
@@ -1308,7 +1322,7 @@ pub const File = struct {
},
.Weak => elf.STB_WEAK,
.LinkOnce => {
- try module.failed_exports.ensureCapacity(module.failed_exports.items().len + 1);
+ try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
module.failed_exports.putAssumeCapacityNoClobber(
exp,
try Module.ErrorMsg.create(self.allocator, 0, "Unimplemented: GlobalLinkage.LinkOnce", .{}),
diff --git a/src-self-hosted/liveness.zig b/src-self-hosted/liveness.zig
@@ -0,0 +1,139 @@
+const std = @import("std");
+const ir = @import("ir.zig");
+const trace = @import("tracy.zig").trace;
+
+/// Perform Liveness Analysis over the `Body`. Each `Inst` will have its `deaths` field populated.
+pub fn analyze(
+ /// Used for temporary storage during the analysis.
+ gpa: *std.mem.Allocator,
+ /// Used to tack on extra allocations in the same lifetime as the existing instructions.
+ arena: *std.mem.Allocator,
+ body: ir.Body,
+) error{OutOfMemory}!void {
+ const tracy = trace(@src());
+ defer tracy.end();
+
+ var table = std.AutoHashMap(*ir.Inst, void).init(gpa);
+ defer table.deinit();
+ try table.ensureCapacity(body.instructions.len);
+ try analyzeWithTable(arena, &table, body);
+}
+
+fn analyzeWithTable(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), body: ir.Body) error{OutOfMemory}!void {
+ var i: usize = body.instructions.len;
+
+ while (i != 0) {
+ i -= 1;
+ const base = body.instructions[i];
+ try analyzeInstGeneric(arena, table, base);
+ }
+}
+
+fn analyzeInstGeneric(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), base: *ir.Inst) error{OutOfMemory}!void {
+ // Obtain the corresponding instruction type based on the tag type.
+ inline for (std.meta.declarations(ir.Inst)) |decl| {
+ switch (decl.data) {
+ .Type => |T| {
+ if (@hasDecl(T, "base_tag")) {
+ if (T.base_tag == base.tag) {
+ return analyzeInst(arena, table, T, @fieldParentPtr(T, "base", base));
+ }
+ }
+ },
+ else => {},
+ }
+ }
+ unreachable;
+}
+
+fn analyzeInst(arena: *std.mem.Allocator, table: *std.AutoHashMap(*ir.Inst, void), comptime T: type, inst: *T) error{OutOfMemory}!void {
+ inst.base.deaths = 0;
+
+ switch (T) {
+ ir.Inst.Constant => return,
+ ir.Inst.Block => {
+ try analyzeWithTable(arena, table, inst.args.body);
+ // We let this continue so that it can possibly mark the block as
+ // unreferenced below.
+ },
+ ir.Inst.CondBr => {
+ var true_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
+ defer true_table.deinit();
+ try true_table.ensureCapacity(inst.args.true_body.instructions.len);
+ try analyzeWithTable(arena, &true_table, inst.args.true_body);
+
+ var false_table = std.AutoHashMap(*ir.Inst, void).init(table.allocator);
+ defer false_table.deinit();
+ try false_table.ensureCapacity(inst.args.false_body.instructions.len);
+ try analyzeWithTable(arena, &false_table, inst.args.false_body);
+
+ // Each death that occurs inside one branch, but not the other, needs
+ // to be added as a death immediately upon entering the other branch.
+ // During the iteration of the table, we additionally propagate the
+ // deaths to the parent table.
+ var true_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
+ defer true_entry_deaths.deinit();
+ var false_entry_deaths = std.ArrayList(*ir.Inst).init(table.allocator);
+ defer false_entry_deaths.deinit();
+ {
+ var it = false_table.iterator();
+ while (it.next()) |entry| {
+ const false_death = entry.key;
+ if (!true_table.contains(false_death)) {
+ try true_entry_deaths.append(false_death);
+ // Here we are only adding to the parent table if the following iteration
+ // would miss it.
+ try table.putNoClobber(false_death, {});
+ }
+ }
+ }
+ {
+ var it = true_table.iterator();
+ while (it.next()) |entry| {
+ const true_death = entry.key;
+ try table.putNoClobber(true_death, {});
+ if (!false_table.contains(true_death)) {
+ try false_entry_deaths.append(true_death);
+ }
+ }
+ }
+ inst.true_death_count = std.math.cast(@TypeOf(inst.true_death_count), true_entry_deaths.items.len) catch return error.OutOfMemory;
+ inst.false_death_count = std.math.cast(@TypeOf(inst.false_death_count), false_entry_deaths.items.len) catch return error.OutOfMemory;
+ const allocated_slice = try arena.alloc(*ir.Inst, true_entry_deaths.items.len + false_entry_deaths.items.len);
+ inst.deaths = allocated_slice.ptr;
+
+ // Continue on with the instruction analysis. The following code will find the condition
+ // instruction, and the deaths flag for the CondBr instruction will indicate whether the
+ // condition's lifetime ends immediately before entering any branch.
+ },
+ else => {},
+ }
+
+ if (!table.contains(&inst.base)) {
+ // No tombstone for this instruction means it is never referenced,
+ // and its birth marks its own death. Very metal 🤘
+ inst.base.deaths |= 1 << 7;
+ }
+
+ const Args = ir.Inst.Args(T);
+ if (Args == void) {
+ return;
+ }
+
+ comptime var arg_index: usize = 0;
+ inline for (std.meta.fields(Args)) |field| {
+ if (field.field_type == *ir.Inst) {
+ if (arg_index >= 6) {
+ @compileError("out of bits to mark deaths of operands");
+ }
+ const prev = try table.fetchPut(@field(inst.args, field.name), {});
+ if (prev == null) {
+ // Death.
+ inst.base.deaths |= 1 << arg_index;
+ }
+ arg_index += 1;
+ }
+ }
+
+ std.log.debug(.liveness, "analyze {}: 0b{b}\n", .{inst.base.tag, inst.base.deaths});
+}
diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig
@@ -50,7 +50,10 @@ pub fn log(
const scope_prefix = "(" ++ switch (scope) {
// Uncomment to hide logs
//.compiler,
- .link => return,
+ .module,
+ .liveness,
+ .link,
+ => return,
else => @tagName(scope),
} ++ "): ";
@@ -510,7 +513,7 @@ fn updateModule(gpa: *Allocator, module: *Module, zir_out_path: ?[]const u8) !vo
const update_nanos = timer.read();
var errors = try module.getAllErrorsAlloc();
- defer errors.deinit(module.allocator);
+ defer errors.deinit(module.gpa);
if (errors.list.len != 0) {
for (errors.list) |full_err_msg| {
diff --git a/src-self-hosted/zir.zig b/src-self-hosted/zir.zig
@@ -38,6 +38,8 @@ pub const Inst = struct {
arg,
/// A labeled block of code, which can return a value.
block,
+ /// Return a value from a `Block`.
+ @"break",
breakpoint,
/// Same as `break` but without an operand; the operand is assumed to be the void value.
breakvoid,
@@ -57,6 +59,7 @@ pub const Inst = struct {
/// String Literal. Makes an anonymous Decl and then takes a pointer to it.
str,
int,
+ inttype,
ptrtoint,
fieldptr,
deref,
@@ -73,6 +76,7 @@ pub const Inst = struct {
bitcast,
elemptr,
add,
+ sub,
cmp,
condbr,
isnull,
@@ -83,6 +87,7 @@ pub const Inst = struct {
return switch (tag) {
.arg => Arg,
.block => Block,
+ .@"break" => Break,
.breakpoint => Breakpoint,
.breakvoid => BreakVoid,
.call => Call,
@@ -94,6 +99,7 @@ pub const Inst = struct {
.@"const" => Const,
.str => Str,
.int => Int,
+ .inttype => IntType,
.ptrtoint => PtrToInt,
.fieldptr => FieldPtr,
.deref => Deref,
@@ -110,6 +116,7 @@ pub const Inst = struct {
.bitcast => BitCast,
.elemptr => ElemPtr,
.add => Add,
+ .sub => Sub,
.cmp => Cmp,
.condbr => CondBr,
.isnull => IsNull,
@@ -139,12 +146,22 @@ pub const Inst = struct {
base: Inst,
positionals: struct {
- label: []const u8,
body: Module.Body,
},
kw_args: struct {},
};
+ pub const Break = struct {
+ pub const base_tag = Tag.@"break";
+ base: Inst,
+
+ positionals: struct {
+ block: *Block,
+ operand: *Inst,
+ },
+ kw_args: struct {},
+ };
+
pub const Breakpoint = struct {
pub const base_tag = Tag.breakpoint;
base: Inst,
@@ -158,7 +175,7 @@ pub const Inst = struct {
base: Inst,
positionals: struct {
- label: []const u8,
+ block: *Block,
},
kw_args: struct {},
};
@@ -367,6 +384,17 @@ pub const Inst = struct {
},
};
+ pub const IntType = struct {
+ pub const base_tag = Tag.inttype;
+ base: Inst,
+
+ positionals: struct {
+ signed: *Inst,
+ bits: *Inst,
+ },
+ kw_args: struct {},
+ };
+
pub const Export = struct {
pub const base_tag = Tag.@"export";
base: Inst,
@@ -512,6 +540,19 @@ pub const Inst = struct {
kw_args: struct {},
};
+ pub const Sub = struct {
+ pub const base_tag = Tag.sub;
+ base: Inst,
+
+ positionals: struct {
+ lhs: *Inst,
+ rhs: *Inst,
+ },
+ kw_args: struct {},
+ };
+
+ /// TODO get rid of the op positional arg and make that data part of
+ /// the base Inst tag.
pub const Cmp = struct {
pub const base_tag = Tag.cmp;
base: Inst,
@@ -582,8 +623,6 @@ pub const Module = struct {
self.writeToStream(std.heap.page_allocator, std.io.getStdErr().outStream()) catch {};
}
- const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize, name: []const u8 });
-
const DeclAndIndex = struct {
decl: *Decl,
index: usize,
@@ -617,80 +656,100 @@ pub const Module = struct {
/// 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();
+ var write = Writer{
+ .module = &self,
+ .inst_table = InstPtrTable.init(allocator),
+ .block_table = std.AutoHashMap(*Inst.Block, []const u8).init(allocator),
+ .arena = std.heap.ArenaAllocator.init(allocator),
+ .indent = 2,
+ };
+ defer write.arena.deinit();
+ defer write.inst_table.deinit();
+ defer write.block_table.deinit();
- try inst_table.ensureCapacity(self.decls.len);
+ // First, build a map of *Inst to @ or % indexes
+ try write.inst_table.ensureCapacity(self.decls.len);
for (self.decls) |decl, decl_i| {
- try inst_table.putNoClobber(decl.inst, .{ .inst = decl.inst, .index = null, .name = decl.name });
+ try write.inst_table.putNoClobber(decl.inst, .{ .inst = decl.inst, .index = null, .name = decl.name });
if (decl.inst.cast(Inst.Fn)) |fn_inst| {
for (fn_inst.positionals.body.instructions) |inst, inst_i| {
- try inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i, .name = undefined });
+ try write.inst_table.putNoClobber(inst, .{ .inst = inst, .index = inst_i, .name = undefined });
}
}
}
for (self.decls) |decl, i| {
try stream.print("@{} ", .{decl.name});
- try self.writeInstToStream(stream, decl.inst, &inst_table);
+ try write.writeInstToStream(stream, decl.inst);
try stream.writeByte('\n');
}
}
+};
+
+const InstPtrTable = std.AutoHashMap(*Inst, struct { inst: *Inst, index: ?usize, name: []const u8 });
+
+const Writer = struct {
+ module: *const Module,
+ inst_table: InstPtrTable,
+ block_table: std.AutoHashMap(*Inst.Block, []const u8),
+ arena: std.heap.ArenaAllocator,
+ indent: usize,
+
fn writeInstToStream(
- self: Module,
+ self: *Writer,
stream: var,
inst: *Inst,
- inst_table: *const InstPtrTable,
- ) @TypeOf(stream).Error!void {
+ ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
// TODO I tried implementing this with an inline for loop and hit a compiler bug
switch (inst.tag) {
- .arg => return self.writeInstToStreamGeneric(stream, .arg, inst, inst_table),
- .block => return self.writeInstToStreamGeneric(stream, .block, inst, inst_table),
- .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, inst, inst_table),
- .breakvoid => return self.writeInstToStreamGeneric(stream, .breakvoid, inst, inst_table),
- .call => return self.writeInstToStreamGeneric(stream, .call, inst, inst_table),
- .declref => return self.writeInstToStreamGeneric(stream, .declref, inst, inst_table),
- .declref_str => return self.writeInstToStreamGeneric(stream, .declref_str, inst, inst_table),
- .declval => return self.writeInstToStreamGeneric(stream, .declval, inst, inst_table),
- .declval_in_module => return self.writeInstToStreamGeneric(stream, .declval_in_module, inst, inst_table),
- .compileerror => return self.writeInstToStreamGeneric(stream, .compileerror, inst, inst_table),
- .@"const" => return self.writeInstToStreamGeneric(stream, .@"const", inst, inst_table),
- .str => return self.writeInstToStreamGeneric(stream, .str, inst, inst_table),
- .int => return self.writeInstToStreamGeneric(stream, .int, inst, inst_table),
- .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, inst, inst_table),
- .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, inst, inst_table),
- .deref => return self.writeInstToStreamGeneric(stream, .deref, inst, inst_table),
- .as => return self.writeInstToStreamGeneric(stream, .as, inst, inst_table),
- .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", inst, inst_table),
- .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", inst, inst_table),
- .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", inst, inst_table),
- .returnvoid => return self.writeInstToStreamGeneric(stream, .returnvoid, inst, inst_table),
- .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", inst, inst_table),
- .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", inst, inst_table),
- .primitive => return self.writeInstToStreamGeneric(stream, .primitive, inst, inst_table),
- .fntype => return self.writeInstToStreamGeneric(stream, .fntype, inst, inst_table),
- .intcast => return self.writeInstToStreamGeneric(stream, .intcast, inst, inst_table),
- .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, inst, inst_table),
- .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, inst, inst_table),
- .add => return self.writeInstToStreamGeneric(stream, .add, inst, inst_table),
- .cmp => return self.writeInstToStreamGeneric(stream, .cmp, inst, inst_table),
- .condbr => return self.writeInstToStreamGeneric(stream, .condbr, inst, inst_table),
- .isnull => return self.writeInstToStreamGeneric(stream, .isnull, inst, inst_table),
- .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, inst, inst_table),
+ .arg => return self.writeInstToStreamGeneric(stream, .arg, inst),
+ .block => return self.writeInstToStreamGeneric(stream, .block, inst),
+ .@"break" => return self.writeInstToStreamGeneric(stream, .@"break", inst),
+ .breakpoint => return self.writeInstToStreamGeneric(stream, .breakpoint, inst),
+ .breakvoid => return self.writeInstToStreamGeneric(stream, .breakvoid, inst),
+ .call => return self.writeInstToStreamGeneric(stream, .call, inst),
+ .declref => return self.writeInstToStreamGeneric(stream, .declref, inst),
+ .declref_str => return self.writeInstToStreamGeneric(stream, .declref_str, inst),
+ .declval => return self.writeInstToStreamGeneric(stream, .declval, inst),
+ .declval_in_module => return self.writeInstToStreamGeneric(stream, .declval_in_module, inst),
+ .compileerror => return self.writeInstToStreamGeneric(stream, .compileerror, inst),
+ .@"const" => return self.writeInstToStreamGeneric(stream, .@"const", inst),
+ .str => return self.writeInstToStreamGeneric(stream, .str, inst),
+ .int => return self.writeInstToStreamGeneric(stream, .int, inst),
+ .inttype => return self.writeInstToStreamGeneric(stream, .inttype, inst),
+ .ptrtoint => return self.writeInstToStreamGeneric(stream, .ptrtoint, inst),
+ .fieldptr => return self.writeInstToStreamGeneric(stream, .fieldptr, inst),
+ .deref => return self.writeInstToStreamGeneric(stream, .deref, inst),
+ .as => return self.writeInstToStreamGeneric(stream, .as, inst),
+ .@"asm" => return self.writeInstToStreamGeneric(stream, .@"asm", inst),
+ .@"unreachable" => return self.writeInstToStreamGeneric(stream, .@"unreachable", inst),
+ .@"return" => return self.writeInstToStreamGeneric(stream, .@"return", inst),
+ .returnvoid => return self.writeInstToStreamGeneric(stream, .returnvoid, inst),
+ .@"fn" => return self.writeInstToStreamGeneric(stream, .@"fn", inst),
+ .@"export" => return self.writeInstToStreamGeneric(stream, .@"export", inst),
+ .primitive => return self.writeInstToStreamGeneric(stream, .primitive, inst),
+ .fntype => return self.writeInstToStreamGeneric(stream, .fntype, inst),
+ .intcast => return self.writeInstToStreamGeneric(stream, .intcast, inst),
+ .bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, inst),
+ .elemptr => return self.writeInstToStreamGeneric(stream, .elemptr, inst),
+ .add => return self.writeInstToStreamGeneric(stream, .add, inst),
+ .sub => return self.writeInstToStreamGeneric(stream, .sub, inst),
+ .cmp => return self.writeInstToStreamGeneric(stream, .cmp, inst),
+ .condbr => return self.writeInstToStreamGeneric(stream, .condbr, inst),
+ .isnull => return self.writeInstToStreamGeneric(stream, .isnull, inst),
+ .isnonnull => return self.writeInstToStreamGeneric(stream, .isnonnull, inst),
}
}
fn writeInstToStreamGeneric(
- self: Module,
+ self: *Writer,
stream: var,
comptime inst_tag: Inst.Tag,
base: *Inst,
- inst_table: *const InstPtrTable,
- ) !void {
+ ) (@TypeOf(stream).Error || error{OutOfMemory})!void {
const SpecificInst = Inst.TagToType(inst_tag);
const inst = @fieldParentPtr(SpecificInst, "base", base);
const Positionals = @TypeOf(inst.positionals);
@@ -700,7 +759,7 @@ pub const Module = struct {
if (i != 0) {
try stream.writeAll(", ");
}
- try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name), inst_table);
+ try self.writeParamToStream(stream, @field(inst.positionals, arg_field.name));
}
comptime var need_comma = pos_fields.len != 0;
@@ -710,13 +769,13 @@ pub const Module = struct {
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);
+ try self.writeParamToStream(stream, non_optional);
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);
+ try self.writeParamToStream(stream, @field(inst.kw_args, arg_field.name));
need_comma = true;
}
}
@@ -724,29 +783,37 @@ pub const Module = struct {
try stream.writeByte(')');
}
- fn writeParamToStream(self: Module, stream: var, param: var, inst_table: *const InstPtrTable) !void {
+ fn writeParamToStream(self: *Writer, stream: var, param: var) !void {
if (@typeInfo(@TypeOf(param)) == .Enum) {
return stream.writeAll(@tagName(param));
}
switch (@TypeOf(param)) {
- *Inst => return self.writeInstParamToStream(stream, param, inst_table),
+ *Inst => return self.writeInstParamToStream(stream, param),
[]*Inst => {
try stream.writeByte('[');
for (param) |inst, i| {
if (i != 0) {
try stream.writeAll(", ");
}
- try self.writeInstParamToStream(stream, inst, inst_table);
+ try self.writeInstParamToStream(stream, inst);
}
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.writeByteNTimes(' ', self.indent);
+ try stream.print("%{} ", .{i});
+ if (inst.cast(Inst.Block)) |block| {
+ const name = try std.fmt.allocPrint(&self.arena.allocator, "label_{}", .{i});
+ try self.block_table.put(block, name);
+ }
+ self.indent += 2;
+ try self.writeInstToStream(stream, inst);
+ self.indent -= 2;
try stream.writeByte('\n');
}
+ try stream.writeByteNTimes(' ', self.indent - 2);
try stream.writeByte('}');
},
bool => return stream.writeByte("01"[@boolToInt(param)]),
@@ -754,12 +821,16 @@ pub const Module = struct {
BigIntConst, usize => return stream.print("{}", .{param}),
TypedValue => unreachable, // this is a special case
*IrModule.Decl => unreachable, // this is a special case
+ *Inst.Block => {
+ const name = self.block_table.get(param).?;
+ return std.zig.renderStringLiteral(name, stream);
+ },
else => |T| @compileError("unimplemented: rendering parameter of type " ++ @typeName(T)),
}
}
- fn writeInstParamToStream(self: Module, stream: var, inst: *Inst, inst_table: *const InstPtrTable) !void {
- if (inst_table.get(inst)) |info| {
+ fn writeInstParamToStream(self: *Writer, stream: var, inst: *Inst) !void {
+ if (self.inst_table.get(inst)) |info| {
if (info.index) |i| {
try stream.print("%{}", .{info.index});
} else {
@@ -789,7 +860,9 @@ pub fn parse(allocator: *Allocator, source: [:0]const u8) Allocator.Error!Module
.global_name_map = &global_name_map,
.decls = .{},
.unnamed_index = 0,
+ .block_table = std.StringHashMap(*Inst.Block).init(allocator),
};
+ defer parser.block_table.deinit();
errdefer parser.arena.deinit();
parser.parseRoot() catch |err| switch (err) {
@@ -815,6 +888,7 @@ const Parser = struct {
global_name_map: *std.StringHashMap(*Inst),
error_msg: ?ErrorMsg = null,
unnamed_index: usize,
+ block_table: std.StringHashMap(*Inst.Block),
const Body = struct {
instructions: std.ArrayList(*Inst),
@@ -1023,6 +1097,10 @@ const Parser = struct {
.tag = InstType.base_tag,
};
+ if (InstType == Inst.Block) {
+ try self.block_table.put(inst_name, inst_specific);
+ }
+
if (@hasField(InstType, "ty")) {
inst_specific.ty = opt_type orelse {
return self.fail("instruction '" ++ fn_name ++ "' requires type", .{});
@@ -1128,6 +1206,10 @@ const Parser = struct {
},
TypedValue => return self.fail("'const' is a special instruction; not legal in ZIR text", .{}),
*IrModule.Decl => return self.fail("'declval_in_module' is a special instruction; not legal in ZIR text", .{}),
+ *Inst.Block => {
+ const name = try self.parseStringLiteral();
+ return self.block_table.get(name).?;
+ },
else => @compileError("Unimplemented: ir parseParameterGeneric for type " ++ @typeName(T)),
}
return self.fail("TODO parse parameter {}", .{@typeName(T)});
@@ -1191,7 +1273,10 @@ pub fn emit(allocator: *Allocator, old_module: IrModule) !Module {
.next_auto_name = 0,
.names = std.StringHashMap(void).init(allocator),
.primitive_table = std.AutoHashMap(Inst.Primitive.Builtin, *Decl).init(allocator),
+ .indent = 0,
+ .block_table = std.AutoHashMap(*ir.Inst.Block, *Inst.Block).init(allocator),
};
+ defer ctx.block_table.deinit();
defer ctx.decls.deinit(allocator);
defer ctx.names.deinit();
defer ctx.primitive_table.deinit();
@@ -1213,6 +1298,8 @@ const EmitZIR = struct {
names: std.StringHashMap(void),
next_auto_name: usize,
primitive_table: std.AutoHashMap(Inst.Primitive.Builtin, *Decl),
+ indent: usize,
+ block_table: std.AutoHashMap(*ir.Inst.Block, *Inst.Block),
fn emit(self: *EmitZIR) !void {
// Put all the Decls in a list and sort them by name to avoid nondeterminism introduced
@@ -1542,6 +1629,22 @@ const EmitZIR = struct {
};
break :blk &new_inst.base;
},
+ .sub => blk: {
+ const old_inst = inst.cast(ir.Inst.Sub).?;
+ const new_inst = try self.arena.allocator.create(Inst.Sub);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Sub.base_tag,
+ },
+ .positionals = .{
+ .lhs = try self.resolveInst(new_body, old_inst.args.lhs),
+ .rhs = try self.resolveInst(new_body, old_inst.args.rhs),
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
.arg => blk: {
const old_inst = inst.cast(ir.Inst.Arg).?;
const new_inst = try self.arena.allocator.create(Inst.Arg);
@@ -1559,6 +1662,8 @@ const EmitZIR = struct {
const old_inst = inst.cast(ir.Inst.Block).?;
const new_inst = try self.arena.allocator.create(Inst.Block);
+ try self.block_table.put(old_inst, new_inst);
+
var block_body = std.ArrayList(*Inst).init(self.allocator);
defer block_body.deinit();
@@ -1570,14 +1675,47 @@ const EmitZIR = struct {
.tag = Inst.Block.base_tag,
},
.positionals = .{
- .label = try self.autoName(),
.body = .{ .instructions = block_body.toOwnedSlice() },
},
.kw_args = .{},
};
+
+ break :blk &new_inst.base;
+ },
+ .br => blk: {
+ const old_inst = inst.cast(ir.Inst.Br).?;
+ const new_block = self.block_table.get(old_inst.args.block).?;
+ const new_inst = try self.arena.allocator.create(Inst.Break);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.Break.base_tag,
+ },
+ .positionals = .{
+ .block = new_block,
+ .operand = try self.resolveInst(new_body, old_inst.args.operand),
+ },
+ .kw_args = .{},
+ };
break :blk &new_inst.base;
},
.breakpoint => try self.emitTrivial(inst.src, Inst.Breakpoint),
+ .brvoid => blk: {
+ const old_inst = inst.cast(ir.Inst.BrVoid).?;
+ const new_block = self.block_table.get(old_inst.args.block).?;
+ const new_inst = try self.arena.allocator.create(Inst.BreakVoid);
+ new_inst.* = .{
+ .base = .{
+ .src = inst.src,
+ .tag = Inst.BreakVoid.base_tag,
+ },
+ .positionals = .{
+ .block = new_block,
+ },
+ .kw_args = .{},
+ };
+ break :blk &new_inst.base;
+ },
.call => blk: {
const old_inst = inst.cast(ir.Inst.Call).?;
const new_inst = try self.arena.allocator.create(Inst.Call);
@@ -1765,7 +1903,7 @@ const EmitZIR = struct {
},
};
try instructions.append(new_inst);
- try inst_table.putNoClobber(inst, new_inst);
+ try inst_table.put(inst, new_inst);
}
}
@@ -1829,6 +1967,26 @@ const EmitZIR = struct {
};
return self.emitUnnamedDecl(&fntype_inst.base);
},
+ .Int => {
+ const info = ty.intInfo(self.old_module.target());
+ const signed = try self.emitPrimitive(src, if (info.signed) .@"true" else .@"false");
+ const bits_payload = try self.arena.allocator.create(Value.Payload.Int_u64);
+ bits_payload.* = .{ .int = info.bits };
+ const bits = try self.emitComptimeIntVal(src, Value.initPayload(&bits_payload.base));
+ const inttype_inst = try self.arena.allocator.create(Inst.IntType);
+ inttype_inst.* = .{
+ .base = .{
+ .src = src,
+ .tag = Inst.IntType.base_tag,
+ },
+ .positionals = .{
+ .signed = signed.inst,
+ .bits = bits.inst,
+ },
+ .kw_args = .{},
+ };
+ return self.emitUnnamedDecl(&inttype_inst.base);
+ },
else => std.debug.panic("TODO implement emitType for {}", .{ty}),
},
}
