@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

package/compiler/aro/aro/Pragma.zig

@@ -212,8 +212,9 @@ pub const Diagnostic = struct {
 };
 
 pub fn err(pp: *Preprocessor, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype) Compilation.Error!void {
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;

package/compiler/aro/aro/Preprocessor/Diagnostic.zig

@@ -472,3 +472,24 @@ pub const pragma_once_in_main_file: Diagnostic = .{
     .kind = .warning,
     .opt = .@"pragma-once-outside-header",
 };
+
+pub const file_name_is_clang_extension: Diagnostic = .{
+    .fmt = "__FILE_NAME__ is a clang extension",
+    .opt = .@"file-name-extension",
+    .kind = .off,
+    .extension = true,
+};
+
+pub const base_file_is_clang_extension: Diagnostic = .{
+    .fmt = "__BASE_FILE__ is a clang extension",
+    .opt = .@"base-file-extension",
+    .kind = .off,
+    .extension = true,
+};
+
+pub const include_level_is_clang_extension: Diagnostic = .{
+    .fmt = "__INCLUDE_LEVEL__ is a clang extension",
+    .opt = .@"include-level-extension",
+    .kind = .off,
+    .extension = true,
+};

package/compiler/aro/aro/Preprocessor.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
-const Io = std.Io;
 const mem = std.mem;
+const path = std.Io.Dir.path;
 const Allocator = mem.Allocator;
 const assert = std.debug.assert;
 
@@ -79,12 +79,15 @@ pub const Macro = struct {
         });
 
         const Object = enum {
+            base_file,
             file,
+            file_basename,
             line,
             counter,
             date,
             time,
             timestamp,
+            include_level,
         };
 
         const Func = enum {
@@ -216,8 +219,6 @@ pub const Macro = struct {
     }
 };
 
-const Preprocessor = @This();
-
 const ExpansionEntry = struct {
     idx: Tree.TokenIndex,
     locs: [*]Source.Location,
@@ -228,6 +229,8 @@ const TokenState = struct {
     expansion_entries_len: usize,
 };
 
+const Preprocessor = @This();
+
 comp: *Compilation,
 diagnostics: *Diagnostics,
 
@@ -275,6 +278,12 @@ m_times: std.AutoHashMapUnmanaged(Source.Id, u64) = .empty,
 /// The dependency file tracking all includes and embeds.
 dep_file: ?*DepFile = null,
 
+/// Path prefixes to replace when expanding __FILE__
+path_replacements: []const struct { []const u8, []const u8 } = &.{},
+
+/// File used for __BASE_FILE__ macro.
+base_file: Source.Id,
+
 pub const parse = Parser.parse;
 
 pub const Linemarkers = enum {
@@ -286,21 +295,22 @@ pub const Linemarkers = enum {
     numeric_directives,
 };
 
-pub fn init(comp: *Compilation, source_epoch: SourceEpoch) Preprocessor {
-    const pp: Preprocessor = .{
-        .comp = comp,
-        .diagnostics = comp.diagnostics,
-        .arena = .init(comp.gpa),
-        .hideset = .{ .comp = comp },
-        .source_epoch = source_epoch,
+pub const InitOptions = struct {
+    base_file: Source.Id,
+
+    source_epoch: ?SourceEpoch = null,
+    add_builtin_macros: bool = true,
+    path_replacements: []const struct { []const u8, []const u8 } = &.{},
+
+    pub const testing: InitOptions = .{
+        .base_file = undefined,
+        .source_epoch = .default,
+        .add_builtin_macros = false,
     };
-    comp.pragmaEvent(.before_preprocess);
-    return pp;
-}
+};
 
-/// Initialize Preprocessor with builtin macros.
-pub fn initDefault(comp: *Compilation) !Preprocessor {
-    const source_epoch: SourceEpoch = comp.environment.sourceEpoch(comp.io) catch |er| switch (er) {
+pub fn init(comp: *Compilation, options: InitOptions) !Preprocessor {
+    const source_epoch: SourceEpoch = options.source_epoch orelse comp.environment.sourceEpoch(comp.io) catch |er| switch (er) {
         error.InvalidEpoch => blk: {
             const diagnostic: Diagnostic = .invalid_source_epoch;
             try comp.diagnostics.add(.{ .text = diagnostic.fmt, .kind = diagnostic.kind, .opt = diagnostic.opt, .location = null });
@@ -308,9 +318,18 @@ pub fn initDefault(comp: *Compilation) !Preprocessor {
         },
     };
 
-    var pp = init(comp, source_epoch);
+    var pp: Preprocessor = .{
+        .comp = comp,
+        .diagnostics = comp.diagnostics,
+        .arena = .init(comp.gpa),
+        .hideset = .{ .comp = comp },
+        .source_epoch = source_epoch,
+        .base_file = options.base_file,
+        .path_replacements = options.path_replacements,
+    };
     errdefer pp.deinit();
-    try pp.addBuiltinMacros();
+    comp.pragmaEvent(.before_preprocess);
+    if (options.add_builtin_macros) try pp.addBuiltinMacros();
     return pp;
 }
 
@@ -339,7 +358,7 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {
     try pp.addBuiltinMacro("__is_identifier", .{ .func = .is_identifier });
     try pp.addBuiltinMacro("_Pragma", .{ .func = .pragma_operator });
 
-    if (pp.comp.langopts.emulate == .clang) {
+    if (pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) {
         try pp.addBuiltinMacro("__is_target_arch", .{ .func = .is_target_arch });
         try pp.addBuiltinMacro("__is_target_vendor", .{ .func = .is_target_vendor });
         try pp.addBuiltinMacro("__is_target_os", .{ .func = .is_target_os });
@@ -359,6 +378,12 @@ pub fn addBuiltinMacros(pp: *Preprocessor) !void {
     try pp.addBuiltinMacro("__DATE__", .{ .obj = .date });
     try pp.addBuiltinMacro("__TIME__", .{ .obj = .time });
     try pp.addBuiltinMacro("__TIMESTAMP__", .{ .obj = .timestamp });
+
+    if (pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) {
+        try pp.addBuiltinMacro("__BASE_FILE__", .{ .obj = .base_file });
+        try pp.addBuiltinMacro("__FILE_NAME__", .{ .obj = .file_basename });
+        try pp.addBuiltinMacro("__INCLUDE_LEVEL__", .{ .obj = .include_level });
+    }
 }
 
 pub fn deinit(pp: *Preprocessor) void {
@@ -395,7 +420,7 @@ fn mTime(pp: *Preprocessor, source_id: Source.Id) !u64 {
     return gop.value_ptr.*;
 }
 
-pub fn expansionSlice(pp: *Preprocessor, tok: Tree.TokenIndex) []Source.Location {
+pub fn expansionSlice(pp: *const Preprocessor, tok: Tree.TokenIndex) []Source.Location {
     const S = struct {
         fn orderTokenIndex(context: Tree.TokenIndex, item: Tree.TokenIndex) std.math.Order {
             return std.math.order(context, item);
@@ -998,8 +1023,9 @@ fn err(pp: *Preprocessor, loc: anytype, diagnostic: Diagnostic, args: anytype) C
     defer pp.diagnostics.state.suppress_system_headers = old_suppress_system;
     if (diagnostic.show_in_system_headers) pp.diagnostics.state.suppress_system_headers = false;
 
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;
@@ -1027,8 +1053,9 @@ fn err(pp: *Preprocessor, loc: anytype, diagnostic: Diagnostic, args: anytype) C
 }
 
 fn fatal(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args: anytype) Compilation.Error {
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    var allocating: std.Io.Writer.Allocating = .init(bfa.allocator());
     defer allocating.deinit();
 
     Diagnostics.formatArgs(&allocating.writer, fmt, args) catch return error.OutOfMemory;
@@ -1049,8 +1076,9 @@ fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []con
     pp.diagnostics.state.fatal_errors = true;
     defer pp.diagnostics.state.fatal_errors = old;
 
-    var sf = std.heap.stackFallback(1024, pp.comp.gpa);
-    const allocator = sf.get();
+    var bfa_buf: [1024]u8 = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(&bfa_buf, pp.comp.gpa);
+    const allocator = bfa.allocator();
     var buf: std.ArrayList(u8) = .empty;
     defer buf.deinit(allocator);
 
@@ -1065,13 +1093,11 @@ fn fatalNotFound(pp: *Preprocessor, tok: TokenWithExpansionLocs, filename: []con
 
 fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args: anytype) void {
     @branchHint(.cold);
-    const comp = pp.comp;
-    const io = comp.io;
-    const source = comp.getSource(raw.source);
+    const source = pp.comp.getSource(raw.source);
     const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });
 
     var stderr_buf: [4096]u8 = undefined;
-    var stderr = Io.File.stderr().writer(io, &stderr_buf);
+    var stderr = std.Io.File.stderr().writer(pp.comp.io, &stderr_buf);
     const w = &stderr.interface;
 
     w.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;
@@ -1435,7 +1461,37 @@ fn expandObjMacro(pp: *Preprocessor, simple_macro: *const Macro) Error!ExpandBuf
                 .file => {
                     const start = pp.comp.generated_buf.items.len;
                     const source = pp.comp.getSource(pp.expansion_source_loc.id);
-                    try pp.comp.generated_buf.print(gpa, "\"{f}\"\n", .{fmtEscapes(source.path)});
+                    for (pp.path_replacements) |replacement| {
+                        if (mem.cutPrefix(u8, source.path, replacement[0])) |rest| {
+                            try pp.comp.generated_buf.print(gpa, "\"{f}{f}\"", .{ fmtEscapes(replacement[1]), fmtEscapes(rest) });
+                            break;
+                        }
+                    } else {
+                        try pp.comp.generated_buf.print(gpa, "\"{f}\"\n", .{fmtEscapes(source.path)});
+                    }
+
+                    buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
+                },
+                .base_file => {
+                    try pp.err(pp.expansion_source_loc, .base_file_is_clang_extension, .{});
+                    const start = pp.comp.generated_buf.items.len;
+                    const base_file = pp.comp.getSource(pp.base_file);
+                    for (pp.path_replacements) |replacement| {
+                        if (mem.cutPrefix(u8, base_file.path, replacement[0])) |rest| {
+                            try pp.comp.generated_buf.print(gpa, "\"{f}{f}\"", .{ fmtEscapes(replacement[1]), fmtEscapes(rest) });
+                        }
+                    } else {
+                        try pp.comp.generated_buf.print(gpa, "\"{f}\"", .{fmtEscapes(base_file.path)});
+                    }
+
+                    buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
+                },
+                .file_basename => {
+                    try pp.err(pp.expansion_source_loc, .file_name_is_clang_extension, .{});
+                    const start = pp.comp.generated_buf.items.len;
+                    const source = pp.comp.getSource(pp.expansion_source_loc.id);
+                    const basename = path.basename(source.path);
+                    try pp.comp.generated_buf.print(gpa, "\"{f}\"", .{fmtEscapes(basename)});
 
                     buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
                 },
@@ -1472,6 +1528,13 @@ fn expandObjMacro(pp: *Preprocessor, simple_macro: *const Macro) Error!ExpandBuf
                     try pp.writeDateTimeStamp(.fromBuiltin(builtin_kind), timestamp);
                     buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
                 },
+                .include_level => {
+                    try pp.err(pp.expansion_source_loc, .include_level_is_clang_extension, .{});
+                    const start = pp.comp.generated_buf.items.len;
+                    try pp.comp.generated_buf.print(gpa, "{d}\n", .{pp.include_depth});
+
+                    buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .pp_num, tok));
+                },
             },
             else => buf.appendAssumeCapacity(tok),
         }
@@ -1828,7 +1891,11 @@ fn handleBuiltinMacro(pp: *Preprocessor, builtin: Macro.Builtin.Func, param_toks
                     features.hasFeature(pp.comp, ident_str)
                 else
                     features.hasExtension(pp.comp, ident_str),
-                .has_builtin => Builtins.fromName(pp.comp, ident_str) != null or (pp.comp.langopts.emulate == .clang and Macro.Builtin.has_builtin_special_cases.has(ident_str)),
+
+                .has_builtin => Builtins.fromName(pp.comp, ident_str) != null or
+                    ((pp.comp.langopts.emulate == .no or pp.comp.langopts.emulate == .clang) and
+                        Macro.Builtin.has_builtin_special_cases.has(ident_str)),
+
                 .is_target_arch => pp.comp.isTargetArch(ident_str),
                 .is_target_os => pp.comp.isTargetOs(ident_str),
                 .is_target_vendor => pp.comp.isTargetVendor(ident_str),
@@ -1972,7 +2039,7 @@ fn expandFuncMacro(
             },
             .macro_param_no_expand => {
                 if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
-                    hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);
+                    hideset = .none;
                 }
                 const slice = getPasteArgs(args.items[raw.end]);
                 const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
@@ -1980,7 +2047,7 @@ fn expandFuncMacro(
             },
             .macro_param => {
                 if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
-                    hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);
+                    hideset = .none;
                 }
                 const arg = expanded_args.items[raw.end];
                 const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
@@ -2330,9 +2397,10 @@ fn expandFuncMacro(
     for (buf.items) |*tok| {
         try tok.addExpansionLocation(gpa, &.{macro_tok.loc});
         try tok.addExpansionLocation(gpa, macro_expansion_locs);
-        const tok_hidelist = pp.hideset.get(tok.loc);
-        const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hideset);
-        try pp.hideset.put(tok.loc, new_hidelist);
+        if (tok.id.shouldTrackHideset(.func)) {
+            const new_hideset = try pp.hideset.@"union"(pp.hideset.get(tok.loc), hideset);
+            try pp.hideset.put(tok.loc, new_hideset);
+        }
     }
 
     return buf;
@@ -2698,9 +2766,10 @@ fn expandMacroExhaustive(
                         try tok.addExpansionLocation(gpa, &.{macro_tok.loc});
                         try tok.addExpansionLocation(gpa, macro_expansion_locs);
 
-                        const tok_hidelist = pp.hideset.get(tok.loc);
-                        const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hs);
-                        try pp.hideset.put(tok.loc, new_hidelist);
+                        if (tok.id.shouldTrackHideset(.obj)) {
+                            const new_hideset = try pp.hideset.@"union"(pp.hideset.get(tok.loc), hs);
+                            try pp.hideset.put(tok.loc, new_hideset);
+                        }
 
                         if (tok.id == .keyword_defined and eval_ctx == .expr) {
                             if (macro.is_func) {
@@ -2914,7 +2983,10 @@ fn pasteTokens(pp: *Preprocessor, lhs_toks: *ExpandBuf, rhs_toks: []const TokenW
         .placemarker
     else
         pasted_token.id;
-    try lhs_toks.append(gpa, try pp.makeGeneratedToken(start, pasted_id, lhs));
+
+    const hideset = try pp.hideset.intersection(pp.hideset.get(lhs.loc), pp.hideset.get(rhs.loc));
+    const generated_token = try pp.makeGeneratedTokenExtra(start, pasted_id, lhs, hideset);
+    try lhs_toks.append(gpa, generated_token);
 
     if (next.id != .nl and next.id != .eof) {
         try pp.err(lhs, .pasting_formed_invalid, .{pp.comp.generated_buf.items[start..end]});
@@ -2924,7 +2996,7 @@ fn pasteTokens(pp: *Preprocessor, lhs_toks: *ExpandBuf, rhs_toks: []const TokenW
     try bufCopyTokens(gpa, lhs_toks, rhs_toks[rhs_rest..], &.{});
 }
 
-fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs) !TokenWithExpansionLocs {
+fn makeGeneratedTokenExtra(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs, hideset: Hideset.Index) !TokenWithExpansionLocs {
     const gpa = pp.comp.gpa;
     var pasted_token = TokenWithExpansionLocs{ .id = id, .loc = .{
         .id = .generated,
@@ -2934,9 +3006,15 @@ fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: Tok
     pp.generated_line += 1;
     try pasted_token.addExpansionLocation(gpa, &.{source.loc});
     try pasted_token.addExpansionLocation(gpa, source.expansionSlice());
+    try pp.hideset.put(pasted_token.loc, hideset);
+
     return pasted_token;
 }
 
+fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: TokenWithExpansionLocs) !TokenWithExpansionLocs {
+    return pp.makeGeneratedTokenExtra(start, id, source, pp.hideset.get(source.loc));
+}
+
 /// Defines a new macro and warns if it is a duplicate
 fn defineMacro(pp: *Preprocessor, define_tok: RawToken, name_tok: TokenWithExpansionLocs, macro: Macro) Error!void {
     const name_str = pp.expandedSlice(name_tok);
@@ -3898,16 +3976,14 @@ test "Preserve pragma tokens sometimes" {
     const gpa = std.testing.allocator;
     const Test = struct {
         fn runPreprocessor(source_text: []const u8) ![]const u8 {
-            var arena: std.heap.ArenaAllocator = .init(gpa);
-            defer arena.deinit();
-
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
+            var comp = try Compilation.init(.testing);
+            comp.diagnostics = &diagnostics;
             defer comp.deinit();
 
             try comp.addDefaultPragmaHandlers();
 
-            var pp = Preprocessor.init(&comp, .default);
+            var pp = try Preprocessor.init(&comp, .testing);
             defer pp.deinit();
 
             pp.preserve_whitespace = true;
@@ -3966,12 +4042,10 @@ test "destringify" {
             try std.testing.expectEqualStrings(destringified, pp.char_buf.items);
         }
     };
-    var arena: std.heap.ArenaAllocator = .init(gpa);
-    defer arena.deinit();
-    var diagnostics: Diagnostics = .{ .output = .ignore };
-    var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
+    var comp = try Compilation.init(.testing);
     defer comp.deinit();
-    var pp = Preprocessor.init(&comp, .default);
+
+    var pp = try Preprocessor.init(&comp, .testing);
     defer pp.deinit();
 
     try Test.testDestringify(&pp, "hello\tworld\n", "hello\tworld\n");
@@ -4026,20 +4100,20 @@ test "Include guards" {
             };
         }
 
-        fn testIncludeGuard(gpa: std.mem.Allocator, comptime template: []const u8, tok_id: RawToken.Id, expected_guards: u32) !void {
-            var arena_state: std.heap.ArenaAllocator = .init(gpa);
-            defer arena_state.deinit();
-            const arena = arena_state.allocator();
+        fn testIncludeGuard(comptime template: []const u8, tok_id: RawToken.Id, expected_guards: u32) !void {
+            const gpa = std.testing.allocator;
 
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(gpa, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
+            var comp = try Compilation.init(.testing);
+            comp.diagnostics = &diagnostics;
             defer comp.deinit();
-            var pp = Preprocessor.init(&comp, .default);
+            var pp = try Preprocessor.init(&comp, .testing);
             defer pp.deinit();
 
-            const path = try std.fs.path.join(arena, &.{ ".", "bar.h" });
+            const file_path = try path.join(gpa, &.{ ".", "bar.h" });
+            defer gpa.free(file_path);
 
-            _ = try comp.addSourceFromBuffer(path, "int bar = 5;\n");
+            _ = try comp.addSourceFromBuffer(file_path, "int bar = 5;\n");
 
             var buf: std.ArrayList(u8) = .empty;
             defer buf.deinit(gpa);
@@ -4074,14 +4148,14 @@ test "Include guards" {
                 \\#endif
             ;
             const expected_guards: u32 = if (Test.pairsWithIfndef(tag)) 0 else 1;
-            try Test.testIncludeGuard(std.testing.allocator, inside_ifndef_template, tag, expected_guards);
+            try Test.testIncludeGuard(inside_ifndef_template, tag, expected_guards);
 
             const outside_ifndef_template =
                 \\#ifndef FOO
                 \\#endif
                 \\#{s}{s}
             ;
-            try Test.testIncludeGuard(std.testing.allocator, outside_ifndef_template, tag, 0);
+            try Test.testIncludeGuard(outside_ifndef_template, tag, 0);
         }
     }
 }

package/compiler/aro/aro/Target.zig

@@ -229,7 +229,7 @@ pub fn intMaxType(target: *const Target) QualType {
         => return .long,
 
         .x86_64 => switch (target.os.tag) {
-            .windows, .openbsd => {},
+            .windows, .openbsd, .uefi => {},
             else => switch (target.abi) {
                 .gnux32, .muslx32 => {},
                 else => return .long,
@@ -546,18 +546,10 @@ pub fn systemCompiler(target: *const Target) LangOpts.Compiler {
 }
 
 pub fn hasFloat128(target: *const Target) bool {
-    if (target.cpu.arch.isWasm()) return true;
     if (target.os.tag.isDarwin()) return false;
-    if (target.cpu.arch.isPowerPC()) return std.Target.powerpc.featureSetHas(target.cpu.features, .float128);
-    return switch (target.os.tag) {
-        .dragonfly,
-        .haiku,
-        .linux,
-        .openbsd,
-        .illumos,
-        => target.cpu.arch.isX86(),
-        else => false,
-    };
+    if (target.os.tag == .windows) return false;
+    if (target.cpu.arch.isX86()) return true;
+    return target.cTypeBitSize(.longdouble) == 128;
 }
 
 pub fn hasInt128(target: *const Target) bool {
@@ -1238,6 +1230,7 @@ pub fn toLLVMTriple(target: *const Target, buf: []u8) []const u8 {
         .other,
         .plan9,
         .vita,
+        .psp,
         => "unknown",
     };
     writer.writeAll(llvm_os) catch unreachable;
@@ -1356,6 +1349,18 @@ pub fn isPIEDefault(target: *const Target) DefaultPIStatus {
     };
 }
 
+pub fn ppcElfVersion(target: *const Target) u32 {
+    std.debug.assert(target.cpu.arch.isPowerPC());
+    return switch (target.cpu.arch) {
+        .powerpc64le => 2,
+        .powerpc64 => if ((target.os.isAtLeast(.freebsd, .{ .major = 13, .minor = 0, .patch = 0 }) orelse false) or target.os.tag == .openbsd or target.abi.isMusl())
+            2
+        else
+            1,
+        else => 1,
+    };
+}
+
 pub fn isPICdefault(target: *const Target) DefaultPIStatus {
     return switch (target.os.tag) {
         .haiku,

package/compiler/aro/aro/Tokenizer.zig

@@ -1,5 +1,4 @@
 const std = @import("std");
-const Io = std.Io;
 const assert = std.debug.assert;
 
 const Compilation = @import("Compilation.zig");
@@ -891,6 +890,14 @@ pub const Token = struct {
                 else => false,
             };
         }
+
+        pub fn shouldTrackHideset(id: Id, context: enum { func, obj }) bool {
+            return switch (id) {
+                .identifier, .extended_identifier => true,
+                .r_paren => context == .func,
+                else => false,
+            };
+        }
     };
 
     /// double underscore and underscore + capital letter identifiers
@@ -938,6 +945,18 @@ pub const Token = struct {
             .keyword_unaligned,
             .keyword_unaligned2,
             => if (langopts.ms_extensions) kw else .identifier,
+
+            .keyword_float32,
+            .keyword_float64,
+            .keyword_float128,
+            .keyword_float32x,
+            .keyword_float64x,
+            .keyword_float128x,
+            .keyword_dfloat32,
+            .keyword_dfloat64,
+            .keyword_dfloat128,
+            .keyword_dfloat64x,
+            => if (langopts.emulate == .clang) .identifier else kw,
             else => kw,
         };
     }
@@ -2008,11 +2027,11 @@ test "operators" {
 test "keywords" {
     try expectTokens(
         \\auto __auto_type break case char const continue default do
-        \\double else enum extern float for goto if int 
-        \\long register return short signed sizeof static 
-        \\struct switch typedef union unsigned void volatile 
-        \\while _Bool _Complex _Imaginary inline restrict _Alignas 
-        \\_Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local 
+        \\double else enum extern float for goto if int
+        \\long register return short signed sizeof static
+        \\struct switch typedef union unsigned void volatile
+        \\while _Bool _Complex _Imaginary inline restrict _Alignas
+        \\_Alignof _Atomic _Generic _Noreturn _Static_assert _Thread_local
         \\__attribute __attribute__
         \\
     , &.{
@@ -2324,13 +2343,13 @@ test "Universal character names" {
 
 test "Tokenizer fuzz test" {
     const Context = struct {
-        fn testOne(_: @This(), input_bytes: []const u8) anyerror!void {
-            var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
-            defer arena.deinit();
-            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
+        fn testOne(_: @This(), smith: *std.testing.Smith) anyerror!void {
+            var comp = try Compilation.init(.testing);
             defer comp.deinit();
 
-            const source = try comp.addSourceFromBuffer("fuzz.c", input_bytes);
+            var buf: [256]u8 = undefined;
+            const contents_len = smith.slice(&buf);
+            const source = try comp.addSourceFromBuffer("fuzz.c", buf[0..contents_len]);
 
             var tokenizer: Tokenizer = .{
                 .buf = source.buf,
@@ -2350,9 +2369,7 @@ test "Tokenizer fuzz test" {
 }
 
 fn expectTokensExtra(contents: []const u8, expected_tokens: []const Token.Id, langopts: ?LangOpts) !void {
-    var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
-    defer arena.deinit();
-    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
+    var comp = try Compilation.init(.testing);
     defer comp.deinit();
     if (langopts) |provided| {
         comp.langopts = provided;

package/compiler/aro/aro/Toolchain.zig

@@ -495,9 +495,9 @@ pub fn addSystemIncludeDir(tc: *const Toolchain, path: []const u8) !void {
 pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
     const d = tc.driver;
     const comp = d.comp;
+    const io = comp.io;
     const gpa = comp.gpa;
     const arena = comp.arena;
-    const io = comp.io;
     try d.includes.ensureUnusedCapacity(gpa, 1);
     if (d.resource_dir) |resource_dir| {
         const path = try std.fs.path.join(arena, &.{ resource_dir, "include" });
@@ -524,14 +524,12 @@ pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
 /// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
 pub fn readFile(tc: *const Toolchain, path: []const u8, buf: []u8) ?[]const u8 {
     const comp = tc.driver.comp;
-    const io = comp.io;
-    return comp.cwd.readFile(io, path, buf) catch null;
+    return comp.cwd.readFile(comp.io, path, buf) catch null;
 }
 
 pub fn exists(tc: *const Toolchain, path: []const u8) bool {
     const comp = tc.driver.comp;
-    const io = comp.io;
-    comp.cwd.access(io, path, .{}) catch return false;
+    comp.cwd.access(comp.io, path, .{}) catch return false;
     return true;
 }
 
@@ -549,8 +547,7 @@ pub fn canExecute(tc: *const Toolchain, path: []const u8) bool {
     }
 
     const comp = tc.driver.comp;
-    const io = comp.io;
-    comp.cwd.access(io, path, .{ .execute = true }) catch return false;
+    comp.cwd.access(comp.io, path, .{ .execute = true }) catch return false;
     // Todo: ensure path is not a directory
     return true;
 }