aro: update

This is f5fb720a5399ee98e45f36337b2f68a4d23a783c plus ehaas's nonnull
attribute pull request currently at 4b26cb3ac610a0a070fc43e43da8b4cdf0e9101b
with zig patches intact.

Author: andrewrk

lib/compiler/aro/aro/Attribute.zig

@@ -312,12 +312,13 @@ pub const Iterator = struct {
 };
 
 test Iterator {
+    const gpa = std.testing.allocator;
     var it = Iterator{};
 
-    var seen = std.StringHashMap(Builtin).init(std.testing.allocator);
-    defer seen.deinit();
+    var seen: std.StringHashMapUnmanaged(Builtin) = .empty;
+    defer seen.deinit(gpa);
 
-    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
+    var arena_state = std.heap.ArenaAllocator.init(gpa);
     defer arena_state.deinit();
     const arena = arena_state.allocator();
 
@@ -333,7 +334,7 @@ test Iterator {
             std.debug.print("previous data: {}\n", .{seen.get(entry.name).?});
             return error.TestExpectedUniqueEntries;
         }
-        try seen.put(try arena.dupe(u8, entry.name), entry.builtin);
+        try seen.put(gpa, try arena.dupe(u8, entry.name), entry.builtin);
     }
     try std.testing.expectEqual(@as(usize, Builtin.data.len), seen.count());
 }

lib/compiler/aro/aro/Attribute/names.zig

@@ -40,11 +40,11 @@ tree: *const Tree,
 comp: *Compilation,
 builder: Builder,
 wip_switch: *WipSwitch = undefined,
-symbols: std.ArrayListUnmanaged(Symbol) = .{},
-ret_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .{},
-phi_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .{},
-record_elem_buf: std.ArrayListUnmanaged(Interner.Ref) = .{},
-record_cache: std.AutoHashMapUnmanaged(QualType, Interner.Ref) = .{},
+symbols: std.ArrayList(Symbol) = .empty,
+ret_nodes: std.ArrayList(Ir.Inst.Phi.Input) = .empty,
+phi_nodes: std.ArrayList(Ir.Inst.Phi.Input) = .empty,
+record_elem_buf: std.ArrayList(Interner.Ref) = .empty,
+record_cache: std.AutoHashMapUnmanaged(QualType, Interner.Ref) = .empty,
 cond_dummy_ty: ?Interner.Ref = null,
 bool_invert: bool = false,
 bool_end_label: Ir.Ref = .none,
@@ -56,10 +56,11 @@ compound_assign_dummy: ?Ir.Ref = null,
 
 fn fail(c: *CodeGen, comptime fmt: []const u8, args: anytype) error{ FatalError, OutOfMemory } {
     var sf = std.heap.stackFallback(1024, c.comp.gpa);
-    var buf = std.ArrayList(u8).init(sf.get());
-    defer buf.deinit();
+    const allocator = sf.get();
+    var buf: std.ArrayList(u8) = .empty;
+    defer buf.deinit(allocator);
 
-    try buf.print(fmt, args);
+    try buf.print(allocator, fmt, args);
     try c.comp.diagnostics.add(.{ .text = buf.items, .kind = .@"fatal error", .location = null });
     return error.FatalError;
 }

lib/compiler/aro/aro/Builtins.zig

@@ -4,8 +4,9 @@ const EpochSeconds = std.time.epoch.EpochSeconds;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 
-const Interner = @import("../backend.zig").Interner;
-const CodeGenOptions = @import("../backend.zig").CodeGenOptions;
+const backend = @import("../backend.zig");
+const Interner = backend.Interner;
+const CodeGenOptions = backend.CodeGenOptions;
 
 const Builtins = @import("Builtins.zig");
 const Builtin = Builtins.Builtin;
@@ -127,24 +128,24 @@ diagnostics: *Diagnostics,
 
 code_gen_options: CodeGenOptions = .default,
 environment: Environment = .{},
-sources: std.StringArrayHashMapUnmanaged(Source) = .{},
+sources: std.StringArrayHashMapUnmanaged(Source) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+include_dirs: std.ArrayList([]const u8) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-system_include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+system_include_dirs: std.ArrayList([]const u8) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-after_include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+after_include_dirs: std.ArrayList([]const u8) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-framework_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+framework_dirs: std.ArrayList([]const u8) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-system_framework_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+system_framework_dirs: std.ArrayList([]const u8) = .empty,
 /// Allocated into `gpa`, but keys are externally managed.
-embed_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+embed_dirs: std.ArrayList([]const u8) = .empty,
 target: std.Target = @import("builtin").target,
 cmodel: std.builtin.CodeModel = .default,
-pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .{},
+pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .empty,
 langopts: LangOpts = .{},
-generated_buf: std.ArrayListUnmanaged(u8) = .{},
+generated_buf: std.ArrayList(u8) = .empty,
 builtins: Builtins = .{},
 string_interner: StringInterner = .{},
 interner: Interner = .{},
@@ -245,6 +246,13 @@ fn generateSystemDefines(comp: *Compilation, w: *std.Io.Writer) !void {
         try w.print("#define __GNUC_PATCHLEVEL__ {d}\n", .{comp.langopts.gnuc_version % 100});
     }
 
+    if (comp.code_gen_options.optimization_level.hasAnyOptimizations()) {
+        try define(w, "__OPTIMIZE__");
+    }
+    if (comp.code_gen_options.optimization_level.isSizeOptimized()) {
+        try define(w, "__OPTIMIZE_SIZE__");
+    }
+
     // os macros
     switch (comp.target.os.tag) {
         .linux => try defineStd(w, "linux", is_gnu),
@@ -1384,8 +1392,8 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8,
     const duped_path = try comp.gpa.dupe(u8, path);
     errdefer comp.gpa.free(duped_path);
 
-    var splice_list = std.array_list.Managed(u32).init(comp.gpa);
-    defer splice_list.deinit();
+    var splice_list: std.ArrayList(u32) = .empty;
+    defer splice_list.deinit(comp.gpa);
 
     const source_id: Source.Id = @enumFromInt(comp.sources.count() + 2);
 
@@ -1418,9 +1426,9 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8,
                     },
                     .back_slash, .trailing_ws, .back_slash_cr => {
                         i = backslash_loc;
-                        try splice_list.append(i);
+                        try splice_list.append(comp.gpa, i);
                         if (state == .trailing_ws) {
-                            try comp.addNewlineEscapeError(path, buf, splice_list.items, i, line);
+                            try comp.addNewlineEscapeError(path, buf, splice_list.items, i, line, kind);
                         }
                         state = if (state == .back_slash_cr) .cr else .back_slash_cr;
                     },
@@ -1438,10 +1446,10 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8,
                     .back_slash, .trailing_ws => {
                         i = backslash_loc;
                         if (state == .back_slash or state == .trailing_ws) {
-                            try splice_list.append(i);
+                            try splice_list.append(comp.gpa, i);
                         }
                         if (state == .trailing_ws) {
-                            try comp.addNewlineEscapeError(path, buf, splice_list.items, i, line);
+                            try comp.addNewlineEscapeError(path, buf, splice_list.items, i, line, kind);
                         }
                     },
                     .bom1, .bom2 => break,
@@ -1491,11 +1499,11 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8,
         }
     }
 
-    const splice_locs = try splice_list.toOwnedSlice();
+    const splice_locs = try splice_list.toOwnedSlice(comp.gpa);
     errdefer comp.gpa.free(splice_locs);
 
     if (i != contents.len) {
-        var list: std.ArrayListUnmanaged(u8) = .{
+        var list: std.ArrayList(u8) = .{
             .items = contents[0..i],
             .capacity = contents.len,
         };
@@ -1515,13 +1523,21 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8,
     return source;
 }
 
-fn addNewlineEscapeError(comp: *Compilation, path: []const u8, buf: []const u8, splice_locs: []const u32, byte_offset: u32, line: u32) !void {
+fn addNewlineEscapeError(
+    comp: *Compilation,
+    path: []const u8,
+    buf: []const u8,
+    splice_locs: []const u32,
+    byte_offset: u32,
+    line: u32,
+    kind: Source.Kind,
+) !void {
     // Temporary source for getting the location for errors.
     var tmp_source: Source = .{
         .path = path,
         .buf = buf,
         .id = undefined,
-        .kind = undefined,
+        .kind = kind,
         .splice_locs = splice_locs,
     };
 
@@ -1571,17 +1587,7 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
 }
 
 pub fn addSourceFromFile(comp: *Compilation, file: std.fs.File, path: []const u8, kind: Source.Kind) !Source {
-    var file_buf: [4096]u8 = undefined;
-    var file_reader = file.reader(&file_buf);
-    if (try file_reader.getSize() > std.math.maxInt(u32)) return error.FileTooBig;
-
-    var allocating: std.Io.Writer.Allocating = .init(comp.gpa);
-    _ = allocating.writer.sendFileAll(&file_reader, .limited(std.math.maxInt(u32))) catch |e| switch (e) {
-        error.WriteFailed => return error.OutOfMemory,
-        error.ReadFailed => return file_reader.err.?,
-    };
-
-    const contents = try allocating.toOwnedSlice();
+    const contents = try comp.getFileContents(file, .unlimited);
     errdefer comp.gpa.free(contents);
     return comp.addSourceFromOwnedBuffer(path, contents, kind);
 }
@@ -1676,7 +1682,7 @@ const FindInclude = struct {
             if (try find.checkFrameworkDir(dir, .system)) |res| return res;
         }
         for (comp.after_include_dirs.items) |dir| {
-            if (try find.checkIncludeDir(dir, .user)) |res| return res;
+            if (try find.checkIncludeDir(dir, .system)) |res| return res;
         }
         if (comp.ms_cwd_source_id) |source_id| {
             if (try find.checkMsCwdIncludeDir(source_id)) |res| return res;
@@ -1771,26 +1777,38 @@ pub const IncludeType = enum {
     angle_brackets,
 };
 
-fn getFileContents(comp: *Compilation, path: []const u8, limit: std.Io.Limit) ![]const u8 {
+fn getPathContents(comp: *Compilation, path: []const u8, limit: std.Io.Limit) ![]u8 {
     if (mem.indexOfScalar(u8, path, 0) != null) {
         return error.FileNotFound;
     }
 
     const file = try comp.cwd.openFile(path, .{});
     defer file.close();
+    return comp.getFileContents(file, limit);
+}
 
-    var allocating: std.Io.Writer.Allocating = .init(comp.gpa);
-    defer allocating.deinit();
-
+fn getFileContents(comp: *Compilation, file: std.fs.File, limit: std.Io.Limit) ![]u8 {
     var file_buf: [4096]u8 = undefined;
     var file_reader = file.reader(&file_buf);
-    if (limit.minInt64(try file_reader.getSize()) > std.math.maxInt(u32)) return error.FileTooBig;
-
-    _ = allocating.writer.sendFileAll(&file_reader, limit) catch |err| switch (err) {
-        error.WriteFailed => return error.OutOfMemory,
-        error.ReadFailed => return file_reader.err.?,
-    };
 
+    var allocating: std.Io.Writer.Allocating = .init(comp.gpa);
+    defer allocating.deinit();
+    if (file_reader.getSize()) |size| {
+        const limited_size = limit.minInt64(size);
+        if (limited_size > std.math.maxInt(u32)) return error.FileTooBig;
+        try allocating.ensureUnusedCapacity(limited_size);
+    } else |_| {}
+
+    var remaining = limit.min(.limited(std.math.maxInt(u32)));
+    while (remaining.nonzero()) {
+        const n = file_reader.interface.stream(&allocating.writer, remaining) catch |err| switch (err) {
+            error.EndOfStream => return allocating.toOwnedSlice(),
+            error.WriteFailed => return error.OutOfMemory,
+            error.ReadFailed => return file_reader.err.?,
+        };
+        remaining = remaining.subtract(n).?;
+    }
+    if (limit == .unlimited) return error.FileTooBig;
     return allocating.toOwnedSlice();
 }
 
@@ -1802,9 +1820,10 @@ pub fn findEmbed(
     include_type: IncludeType,
     limit: std.Io.Limit,
     opt_dep_file: ?*DepFile,
-) !?[]const u8 {
+) !?[]u8 {
     if (std.fs.path.isAbsolute(filename)) {
-        if (comp.getFileContents(filename, limit)) |some| {
+        if (comp.getPathContents(filename, limit)) |some| {
+            errdefer comp.gpa.free(some);
             if (opt_dep_file) |dep_file| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
             return some;
         } else |err| switch (err) {
@@ -1824,7 +1843,8 @@ pub fn findEmbed(
             if (comp.langopts.ms_extensions) {
                 std.mem.replaceScalar(u8, path, '\\', '/');
             }
-            if (comp.getFileContents(path, limit)) |some| {
+            if (comp.getPathContents(path, limit)) |some| {
+                errdefer comp.gpa.free(some);
                 if (opt_dep_file) |dep_file| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
                 return some;
             } else |err| switch (err) {
@@ -1840,7 +1860,8 @@ pub fn findEmbed(
         if (comp.langopts.ms_extensions) {
             std.mem.replaceScalar(u8, path, '\\', '/');
         }
-        if (comp.getFileContents(path, limit)) |some| {
+        if (comp.getPathContents(path, limit)) |some| {
+            errdefer comp.gpa.free(some);
             if (opt_dep_file) |dep_file| try dep_file.addDependencyDupe(comp.gpa, comp.arena, filename);
             return some;
         } else |err| switch (err) {

lib/compiler/aro/aro/CodeGen.zig

@@ -28,7 +28,7 @@ pub fn write(d: *const DepFile, w: *std.Io.Writer) std.Io.Writer.Error!void {
     const max_columns = 75;
     var columns: usize = 0;
 
-    try w.writeAll(d.target);
+    try writeTarget(d.target, w);
     columns += d.target.len;
     try w.writeByte(':');
     columns += 1;
@@ -48,6 +48,26 @@ pub fn write(d: *const DepFile, w: *std.Io.Writer) std.Io.Writer.Error!void {
     try w.flush();
 }
 
+fn writeTarget(path: []const u8, w: *std.Io.Writer) !void {
+    for (path, 0..) |c, i| {
+        switch (c) {
+            ' ', '\t' => {
+                try w.writeByte('\\');
+                var j = i;
+                while (j != 0) {
+                    j -= 1;
+                    if (path[j] != '\\') break;
+                    try w.writeByte('\\');
+                }
+            },
+            '$' => try w.writeByte('$'),
+            '#' => try w.writeByte('\\'),
+            else => {},
+        }
+        try w.writeByte(c);
+    }
+}
+
 fn writePath(d: *const DepFile, path: []const u8, w: *std.Io.Writer) !void {
     switch (d.format) {
         .nmake => {
@@ -58,18 +78,19 @@ fn writePath(d: *const DepFile, path: []const u8, w: *std.Io.Writer) !void {
         },
         .make => {
             for (path, 0..) |c, i| {
-                if (c == '#') {
-                    try w.writeByte('\\');
-                } else if (c == '$') {
-                    try w.writeByte('$');
-                } else if (c == ' ') {
-                    try w.writeByte('\\');
-                    var j = i;
-                    while (j != 0) {
-                        j -= 1;
-                        if (path[j] != '\\') break;
+                switch (c) {
+                    ' ' => {
                         try w.writeByte('\\');
-                    }
+                        var j = i;
+                        while (j != 0) {
+                            j -= 1;
+                            if (path[j] != '\\') break;
+                            try w.writeByte('\\');
+                        }
+                    },
+                    '$' => try w.writeByte('$'),
+                    '#' => try w.writeByte('\\'),
+                    else => {},
                 }
                 try w.writeByte(c);
             }