authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-02 07:55:25-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-02 07:55:25-07:00
log14678451848a6683904c24f75333699b4d166a46
tree75de5b34b8a8a298a2e1525aa28340ee0399616b
parent665737d845a5fc5a9182541cbe47643ee6d9f3f6

sync

5 files changed, 143 insertions(+), 154 deletions(-)

src/Air/print.zig+3-3
......@@ -78,9 +78,9 @@ pub fn dump(air: Air, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
7878}
7979
8080pub fn dumpInst(air: Air, inst: Air.Inst.Index, pt: Zcu.PerThread, liveness: ?Air.Liveness) void {
81 var bw = std.debug.lockStdErr2(&.{});
82 defer std.debug.unlockStdErr();
83 air.writeInst(&bw, inst, pt, liveness);
81 const stderr_bw = std.debug.lockStderrWriter(&.{});
82 defer std.debug.unlockStderrWriter();
83 air.writeInst(stderr_bw, inst, pt, liveness);
8484}
8585
8686const Writer = struct {
src/Zcu/PerThread.zig+10-10
......@@ -251,9 +251,9 @@ pub fn updateFile(
251251
252252 const source = try gpa.allocSentinel(u8, @intCast(stat.size), 0);
253253 defer if (file.source == null) gpa.free(source);
254 var source_fr = source_file.reader();
255 var source_br = source_fr.interface().unbuffered();
256 source_br.readSlice(source) catch |err| switch (err) {
254 var source_fr = source_file.reader(&.{});
255 source_fr.size = stat.size;
256 source_fr.interface.readSliceAll(source) catch |err| switch (err) {
257257 error.ReadFailed => return source_fr.err.?,
258258 error.EndOfStream => return error.UnexpectedEndOfFile,
259259 };
......@@ -344,8 +344,8 @@ fn loadZirZoirCache(
344344 };
345345
346346 var buffer: [@sizeOf(Header)]u8 = undefined;
347 var cache_fr = cache_file.reader();
348 var cache_br = cache_fr.interface().buffered(&buffer);
347 var cache_fr = cache_file.reader(&buffer);
348 const cache_br = &cache_fr.interface;
349349
350350 // First we read the header to determine the lengths of arrays.
351351 const header = (cache_br.takeStruct(Header) catch |err| switch (err) {
......@@ -366,12 +366,12 @@ fn loadZirZoirCache(
366366 }
367367
368368 switch (mode) {
369 .zig => file.zir = Zcu.loadZirCacheBody(gpa, header, &cache_br) catch |err| switch (err) {
369 .zig => file.zir = Zcu.loadZirCacheBody(gpa, header, cache_br) catch |err| switch (err) {
370370 error.ReadFailed => return cache_fr.err.?,
371371 error.EndOfStream => return .truncated,
372372 else => |e| return e,
373373 },
374 .zon => file.zoir = Zcu.loadZoirCacheBody(gpa, header, &cache_br) catch |err| switch (err) {
374 .zon => file.zoir = Zcu.loadZoirCacheBody(gpa, header, cache_br) catch |err| switch (err) {
375375 error.ReadFailed => return cache_fr.err.?,
376376 error.EndOfStream => return .truncated,
377377 else => |e| return e,
......@@ -2439,9 +2439,9 @@ fn updateEmbedFileInner(
24392439 const old_len = strings.mutate.len;
24402440 errdefer strings.shrinkRetainingCapacity(old_len);
24412441 const bytes = (try strings.addManyAsSlice(size_plus_one))[0];
2442 var fr = file.reader();
2443 var br = fr.interface().unbuffered();
2444 br.readSlice(bytes[0..size]) catch |err| switch (err) {
2442 var fr = file.reader(&.{});
2443 fr.size = stat.size;
2444 fr.interface.readSliceAll(bytes[0..size]) catch |err| switch (err) {
24452445 error.ReadFailed => return fr.err.?,
24462446 error.EndOfStream => return error.UnexpectedEof,
24472447 };
src/arch/x86_64/encoder.zig+107-115
......@@ -227,89 +227,81 @@ pub const Instruction = struct {
227227 };
228228 }
229229
230 fn format(op: Operand, bw: *Writer, comptime unused_format_string: []const u8) !void {
231 _ = op;
232 _ = bw;
233 _ = unused_format_string;
234 @compileError("do not format Operand directly; use fmt() instead");
235 }
236
237 const FormatContext = struct {
230 const Format = struct {
238231 op: Operand,
239232 enc_op: Encoding.Op,
240 };
241233
242 fn fmtContext(ctx: FormatContext, bw: *Writer, comptime unused_format_string: []const u8) Writer.Error!void {
243 _ = unused_format_string;
244 const op = ctx.op;
245 const enc_op = ctx.enc_op;
246 switch (op) {
247 .none => {},
248 .reg => |reg| try bw.writeAll(@tagName(reg)),
249 .mem => |mem| switch (mem) {
250 .rip => |rip| {
251 try bw.print("{f} [rip", .{rip.ptr_size});
252 if (rip.disp != 0) try bw.print(" {c} 0x{x}", .{
253 @as(u8, if (rip.disp < 0) '-' else '+'),
254 @abs(rip.disp),
255 });
256 try bw.writeByte(']');
257 },
258 .sib => |sib| {
259 try bw.print("{f} ", .{sib.ptr_size});
234 fn default(f: Format, w: *Writer) Writer.Error!void {
235 const op = f.op;
236 const enc_op = f.enc_op;
237 switch (op) {
238 .none => {},
239 .reg => |reg| try w.writeAll(@tagName(reg)),
240 .mem => |mem| switch (mem) {
241 .rip => |rip| {
242 try w.print("{f} [rip", .{rip.ptr_size});
243 if (rip.disp != 0) try w.print(" {c} 0x{x}", .{
244 @as(u8, if (rip.disp < 0) '-' else '+'),
245 @abs(rip.disp),
246 });
247 try w.writeByte(']');
248 },
249 .sib => |sib| {
250 try w.print("{f} ", .{sib.ptr_size});
260251
261 if (mem.isSegmentRegister()) {
262 return bw.print("{s}:0x{x}", .{ @tagName(sib.base.reg), sib.disp });
263 }
252 if (mem.isSegmentRegister()) {
253 return w.print("{s}:0x{x}", .{ @tagName(sib.base.reg), sib.disp });
254 }
264255
265 try bw.writeByte('[');
266
267 var any = true;
268 switch (sib.base) {
269 .none => any = false,
270 .reg => |reg| try bw.print("{s}", .{@tagName(reg)}),
271 .frame => |frame_index| try bw.print("{}", .{frame_index}),
272 .table => try bw.print("Table", .{}),
273 .rip_inst => |inst_index| try bw.print("RipInst({d})", .{inst_index}),
274 .nav => |nav| try bw.print("Nav({d})", .{@intFromEnum(nav)}),
275 .uav => |uav| try bw.print("Uav({d})", .{@intFromEnum(uav.val)}),
276 .lazy_sym => |lazy_sym| try bw.print("LazySym({s}, {d})", .{
277 @tagName(lazy_sym.kind),
278 @intFromEnum(lazy_sym.ty),
279 }),
280 .extern_func => |extern_func| try bw.print("ExternFunc({d})", .{@intFromEnum(extern_func)}),
281 }
282 if (mem.scaleIndex()) |si| {
283 if (any) try bw.writeAll(" + ");
284 try bw.print("{s} * {d}", .{ @tagName(si.index), si.scale });
285 any = true;
286 }
287 if (sib.disp != 0 or !any) {
288 if (any)
289 try bw.print(" {c} ", .{@as(u8, if (sib.disp < 0) '-' else '+')})
290 else if (sib.disp < 0)
291 try bw.writeByte('-');
292 try bw.print("0x{x}", .{@abs(sib.disp)});
293 any = true;
294 }
256 try w.writeByte('[');
257
258 var any = true;
259 switch (sib.base) {
260 .none => any = false,
261 .reg => |reg| try w.print("{s}", .{@tagName(reg)}),
262 .frame => |frame_index| try w.print("{}", .{frame_index}),
263 .table => try w.print("Table", .{}),
264 .rip_inst => |inst_index| try w.print("RipInst({d})", .{inst_index}),
265 .nav => |nav| try w.print("Nav({d})", .{@intFromEnum(nav)}),
266 .uav => |uav| try w.print("Uav({d})", .{@intFromEnum(uav.val)}),
267 .lazy_sym => |lazy_sym| try w.print("LazySym({s}, {d})", .{
268 @tagName(lazy_sym.kind),
269 @intFromEnum(lazy_sym.ty),
270 }),
271 .extern_func => |extern_func| try w.print("ExternFunc({d})", .{@intFromEnum(extern_func)}),
272 }
273 if (mem.scaleIndex()) |si| {
274 if (any) try w.writeAll(" + ");
275 try w.print("{s} * {d}", .{ @tagName(si.index), si.scale });
276 any = true;
277 }
278 if (sib.disp != 0 or !any) {
279 if (any)
280 try w.print(" {c} ", .{@as(u8, if (sib.disp < 0) '-' else '+')})
281 else if (sib.disp < 0)
282 try w.writeByte('-');
283 try w.print("0x{x}", .{@abs(sib.disp)});
284 any = true;
285 }
295286
296 try bw.writeByte(']');
287 try w.writeByte(']');
288 },
289 .moffs => |moffs| try w.print("{s}:0x{x}", .{
290 @tagName(moffs.seg),
291 moffs.offset,
292 }),
297293 },
298 .moffs => |moffs| try bw.print("{s}:0x{x}", .{
299 @tagName(moffs.seg),
300 moffs.offset,
301 }),
302 },
303 .imm => |imm| if (enc_op.isSigned()) {
304 const imms = imm.asSigned(enc_op.immBitSize());
305 if (imms < 0) try bw.writeByte('-');
306 try bw.print("0x{x}", .{@abs(imms)});
307 } else try bw.print("0x{x}", .{imm.asUnsigned(enc_op.immBitSize())}),
308 .bytes => unreachable,
294 .imm => |imm| if (enc_op.isSigned()) {
295 const imms = imm.asSigned(enc_op.immBitSize());
296 if (imms < 0) try w.writeByte('-');
297 try w.print("0x{x}", .{@abs(imms)});
298 } else try w.print("0x{x}", .{imm.asUnsigned(enc_op.immBitSize())}),
299 .bytes => unreachable,
300 }
309301 }
310 }
302 };
311303
312 pub fn fmt(op: Operand, enc_op: Encoding.Op) std.fmt.Formatter(fmtContext) {
304 pub fn fmt(op: Operand, enc_op: Encoding.Op) std.fmt.Formatter(Format, Format.default) {
313305 return .{ .data = .{ .op = op, .enc_op = enc_op } };
314306 }
315307 };
......@@ -361,23 +353,23 @@ pub const Instruction = struct {
361353 return inst;
362354 }
363355
364 pub fn format(inst: Instruction, bw: *Writer, comptime unused_format_string: []const u8) Writer.Error!void {
365 _ = unused_format_string;
356 pub fn format(inst: Instruction, w: *Writer, comptime unused_format_string: []const u8) Writer.Error!void {
357 comptime assert(unused_format_string.len == 0);
366358 switch (inst.prefix) {
367359 .none, .directive => {},
368 else => try bw.print("{s} ", .{@tagName(inst.prefix)}),
360 else => try w.print("{s} ", .{@tagName(inst.prefix)}),
369361 }
370 try bw.print("{s}", .{@tagName(inst.encoding.mnemonic)});
362 try w.print("{s}", .{@tagName(inst.encoding.mnemonic)});
371363 for (inst.ops, inst.encoding.data.ops, 0..) |op, enc, i| {
372364 if (op == .none) break;
373 if (i > 0) try bw.writeByte(',');
374 try bw.print(" {f}", .{op.fmt(enc)});
365 if (i > 0) try w.writeByte(',');
366 try w.print(" {f}", .{op.fmt(enc)});
375367 }
376368 }
377369
378 pub fn encode(inst: Instruction, bw: *Writer, comptime opts: Options) !void {
370 pub fn encode(inst: Instruction, w: *Writer, comptime opts: Options) !void {
379371 assert(inst.prefix != .directive);
380 const encoder: Encoder(opts) = .{ .bw = bw };
372 const encoder: Encoder(opts) = .{ .w = w };
381373 const enc = inst.encoding;
382374 const data = enc.data;
383375
......@@ -785,7 +777,7 @@ pub const Options = struct { allow_frame_locs: bool = false, allow_symbols: bool
785777
786778fn Encoder(comptime opts: Options) type {
787779 return struct {
788 bw: *Writer,
780 w: *Writer,
789781
790782 const Self = @This();
791783 pub const options = opts;
......@@ -800,31 +792,31 @@ fn Encoder(comptime opts: Options) type {
800792 // Hopefully this path isn't taken very often, so we'll do it the slow way for now
801793
802794 // LOCK
803 if (prefixes.prefix_f0) try self.bw.writeByte(0xf0);
795 if (prefixes.prefix_f0) try self.w.writeByte(0xf0);
804796 // REPNZ, REPNE, REP, Scalar Double-precision
805 if (prefixes.prefix_f2) try self.bw.writeByte(0xf2);
797 if (prefixes.prefix_f2) try self.w.writeByte(0xf2);
806798 // REPZ, REPE, REP, Scalar Single-precision
807 if (prefixes.prefix_f3) try self.bw.writeByte(0xf3);
799 if (prefixes.prefix_f3) try self.w.writeByte(0xf3);
808800
809801 // CS segment override or Branch not taken
810 if (prefixes.prefix_2e) try self.bw.writeByte(0x2e);
802 if (prefixes.prefix_2e) try self.w.writeByte(0x2e);
811803 // DS segment override
812 if (prefixes.prefix_36) try self.bw.writeByte(0x36);
804 if (prefixes.prefix_36) try self.w.writeByte(0x36);
813805 // ES segment override
814 if (prefixes.prefix_26) try self.bw.writeByte(0x26);
806 if (prefixes.prefix_26) try self.w.writeByte(0x26);
815807 // FS segment override
816 if (prefixes.prefix_64) try self.bw.writeByte(0x64);
808 if (prefixes.prefix_64) try self.w.writeByte(0x64);
817809 // GS segment override
818 if (prefixes.prefix_65) try self.bw.writeByte(0x65);
810 if (prefixes.prefix_65) try self.w.writeByte(0x65);
819811
820812 // Branch taken
821 if (prefixes.prefix_3e) try self.bw.writeByte(0x3e);
813 if (prefixes.prefix_3e) try self.w.writeByte(0x3e);
822814
823815 // Operand size override
824 if (prefixes.prefix_66) try self.bw.writeByte(0x66);
816 if (prefixes.prefix_66) try self.w.writeByte(0x66);
825817
826818 // Address size override
827 if (prefixes.prefix_67) try self.bw.writeByte(0x67);
819 if (prefixes.prefix_67) try self.w.writeByte(0x67);
828820 }
829821 }
830822
......@@ -832,7 +824,7 @@ fn Encoder(comptime opts: Options) type {
832824 ///
833825 /// Note that this flag is overridden by REX.W, if both are present.
834826 pub fn prefix16BitMode(self: Self) !void {
835 try self.bw.writeByte(0x66);
827 try self.w.writeByte(0x66);
836828 }
837829
838830 /// Encodes a REX prefix byte given all the fields
......@@ -851,7 +843,7 @@ fn Encoder(comptime opts: Options) type {
851843 if (fields.x) byte |= 0b0010;
852844 if (fields.b) byte |= 0b0001;
853845
854 try self.bw.writeByte(byte);
846 try self.w.writeByte(byte);
855847 }
856848
857849 /// Encodes a VEX prefix given all the fields
......@@ -859,24 +851,24 @@ fn Encoder(comptime opts: Options) type {
859851 /// See struct `Vex` for a description of each field.
860852 pub fn vex(self: Self, fields: Vex) !void {
861853 if (fields.is3Byte()) {
862 try self.bw.writeByte(0b1100_0100);
854 try self.w.writeByte(0b1100_0100);
863855
864 try self.bw.writeByte(
856 try self.w.writeByte(
865857 @as(u8, ~@intFromBool(fields.r)) << 7 |
866858 @as(u8, ~@intFromBool(fields.x)) << 6 |
867859 @as(u8, ~@intFromBool(fields.b)) << 5 |
868860 @as(u8, @intFromEnum(fields.m)) << 0,
869861 );
870862
871 try self.bw.writeByte(
863 try self.w.writeByte(
872864 @as(u8, @intFromBool(fields.w)) << 7 |
873865 @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 |
874866 @as(u8, @intFromBool(fields.l)) << 2 |
875867 @as(u8, @intFromEnum(fields.p)) << 0,
876868 );
877869 } else {
878 try self.bw.writeByte(0b1100_0101);
879 try self.bw.writeByte(
870 try self.w.writeByte(0b1100_0101);
871 try self.w.writeByte(
880872 @as(u8, ~@intFromBool(fields.r)) << 7 |
881873 @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 |
882874 @as(u8, @intFromBool(fields.l)) << 2 |
......@@ -891,7 +883,7 @@ fn Encoder(comptime opts: Options) type {
891883
892884 /// Encodes a 1 byte opcode
893885 pub fn opcode_1byte(self: Self, opcode: u8) !void {
894 try self.bw.writeByte(opcode);
886 try self.w.writeByte(opcode);
895887 }
896888
897889 /// Encodes a 2 byte opcode
......@@ -900,7 +892,7 @@ fn Encoder(comptime opts: Options) type {
900892 ///
901893 /// encoder.opcode_2byte(0x0f, 0xaf);
902894 pub fn opcode_2byte(self: Self, prefix: u8, opcode: u8) !void {
903 try self.bw.writeAll(&.{ prefix, opcode });
895 try self.w.writeAll(&.{ prefix, opcode });
904896 }
905897
906898 /// Encodes a 3 byte opcode
......@@ -909,7 +901,7 @@ fn Encoder(comptime opts: Options) type {
909901 ///
910902 /// encoder.opcode_3byte(0xf2, 0x0f, 0x10);
911903 pub fn opcode_3byte(self: Self, prefix_1: u8, prefix_2: u8, opcode: u8) !void {
912 try self.bw.writeAll(&.{ prefix_1, prefix_2, opcode });
904 try self.w.writeAll(&.{ prefix_1, prefix_2, opcode });
913905 }
914906
915907 /// Encodes a 1 byte opcode with a reg field
......@@ -917,7 +909,7 @@ fn Encoder(comptime opts: Options) type {
917909 /// Remember to add a REX prefix byte if reg is extended!
918910 pub fn opcode_withReg(self: Self, opcode: u8, reg: u3) !void {
919911 assert(opcode & 0b111 == 0);
920 try self.bw.writeByte(opcode | reg);
912 try self.w.writeByte(opcode | reg);
921913 }
922914
923915 // ------
......@@ -928,7 +920,7 @@ fn Encoder(comptime opts: Options) type {
928920 ///
929921 /// Remember to add a REX prefix byte if reg or rm are extended!
930922 pub fn modRm(self: Self, mod: u2, reg_or_opx: u3, rm: u3) !void {
931 try self.bw.writeByte(@as(u8, mod) << 6 | @as(u8, reg_or_opx) << 3 | rm);
923 try self.w.writeByte(@as(u8, mod) << 6 | @as(u8, reg_or_opx) << 3 | rm);
932924 }
933925
934926 /// Construct a ModR/M byte using direct r/m addressing
......@@ -1014,7 +1006,7 @@ fn Encoder(comptime opts: Options) type {
10141006 ///
10151007 /// Remember to add a REX prefix byte if index or base are extended!
10161008 pub fn sib(self: Self, scale: u2, index: u3, base: u3) !void {
1017 try self.bw.writeByte(@as(u8, scale) << 6 | @as(u8, index) << 3 | base);
1009 try self.w.writeByte(@as(u8, scale) << 6 | @as(u8, index) << 3 | base);
10181010 }
10191011
10201012 /// Construct a SIB byte with scale * index + base, no frills.
......@@ -1106,42 +1098,42 @@ fn Encoder(comptime opts: Options) type {
11061098 ///
11071099 /// It is sign-extended to 64 bits by the cpu.
11081100 pub fn disp8(self: Self, disp: i8) !void {
1109 try self.bw.writeByte(@as(u8, @bitCast(disp)));
1101 try self.w.writeByte(@as(u8, @bitCast(disp)));
11101102 }
11111103
11121104 /// Encode an 32 bit displacement
11131105 ///
11141106 /// It is sign-extended to 64 bits by the cpu.
11151107 pub fn disp32(self: Self, disp: i32) !void {
1116 try self.bw.writeInt(i32, disp, .little);
1108 try self.w.writeInt(i32, disp, .little);
11171109 }
11181110
11191111 /// Encode an 8 bit immediate
11201112 ///
11211113 /// It is sign-extended to 64 bits by the cpu.
11221114 pub fn imm8(self: Self, imm: u8) !void {
1123 try self.bw.writeByte(imm);
1115 try self.w.writeByte(imm);
11241116 }
11251117
11261118 /// Encode an 16 bit immediate
11271119 ///
11281120 /// It is sign-extended to 64 bits by the cpu.
11291121 pub fn imm16(self: Self, imm: u16) !void {
1130 try self.bw.writeInt(u16, imm, .little);
1122 try self.w.writeInt(u16, imm, .little);
11311123 }
11321124
11331125 /// Encode an 32 bit immediate
11341126 ///
11351127 /// It is sign-extended to 64 bits by the cpu.
11361128 pub fn imm32(self: Self, imm: u32) !void {
1137 try self.bw.writeInt(u32, imm, .little);
1129 try self.w.writeInt(u32, imm, .little);
11381130 }
11391131
11401132 /// Encode an 64 bit immediate
11411133 ///
11421134 /// It is sign-extended to 64 bits by the cpu.
11431135 pub fn imm64(self: Self, imm: u64) !void {
1144 try self.bw.writeInt(u64, imm, .little);
1136 try self.w.writeInt(u64, imm, .little);
11451137 }
11461138 };
11471139}
......@@ -2199,10 +2191,10 @@ const Assembler = struct {
21992191 };
22002192 }
22012193
2202 pub fn assemble(as: *Assembler, bw: *Writer) !void {
2194 pub fn assemble(as: *Assembler, w: *Writer) !void {
22032195 while (try as.next()) |parsed_inst| {
22042196 const inst: Instruction = try .new(.none, parsed_inst.mnemonic, &parsed_inst.ops);
2205 try inst.encode(bw, .{});
2197 try inst.encode(w, .{});
22062198 }
22072199 }
22082200
src/codegen/c/Type.zig+19-24
......@@ -209,7 +209,7 @@ pub fn getStandardDefineAbbrev(ctype: CType) ?[]const u8 {
209209 };
210210}
211211
212pub fn renderLiteralPrefix(ctype: CType, bw: *Writer, kind: Kind, pool: *const Pool) Writer.Error!void {
212pub fn renderLiteralPrefix(ctype: CType, w: *Writer, kind: Kind, pool: *const Pool) Writer.Error!void {
213213 switch (ctype.info(pool)) {
214214 .basic => |basic_info| switch (basic_info) {
215215 .void => unreachable,
......@@ -224,7 +224,7 @@ pub fn renderLiteralPrefix(ctype: CType, bw: *Writer, kind: Kind, pool: *const P
224224 .uintptr_t,
225225 .intptr_t,
226226 => switch (kind) {
227 else => try bw.print("({s})", .{@tagName(basic_info)}),
227 else => try w.print("({s})", .{@tagName(basic_info)}),
228228 .global => {},
229229 },
230230 .int,
......@@ -246,7 +246,7 @@ pub fn renderLiteralPrefix(ctype: CType, bw: *Writer, kind: Kind, pool: *const P
246246 .int32_t,
247247 .uint64_t,
248248 .int64_t,
249 => try bw.print("{s}_C(", .{ctype.getStandardDefineAbbrev().?}),
249 => try w.print("{s}_C(", .{ctype.getStandardDefineAbbrev().?}),
250250 .zig_u128,
251251 .zig_i128,
252252 .zig_f16,
......@@ -255,7 +255,7 @@ pub fn renderLiteralPrefix(ctype: CType, bw: *Writer, kind: Kind, pool: *const P
255255 .zig_f80,
256256 .zig_f128,
257257 .zig_c_longdouble,
258 => try bw.print("zig_{s}_{s}(", .{
258 => try w.print("zig_{s}_{s}(", .{
259259 switch (kind) {
260260 else => "make",
261261 .global => "init",
......@@ -265,12 +265,12 @@ pub fn renderLiteralPrefix(ctype: CType, bw: *Writer, kind: Kind, pool: *const P
265265 .va_list => unreachable,
266266 _ => unreachable,
267267 },
268 .array, .vector => try bw.writeByte('{'),
268 .array, .vector => try w.writeByte('{'),
269269 else => unreachable,
270270 }
271271}
272272
273pub fn renderLiteralSuffix(ctype: CType, bw: *Writer, pool: *const Pool) Writer.Error!void {
273pub fn renderLiteralSuffix(ctype: CType, w: *Writer, pool: *const Pool) Writer.Error!void {
274274 switch (ctype.info(pool)) {
275275 .basic => |basic_info| switch (basic_info) {
276276 .void => unreachable,
......@@ -280,20 +280,20 @@ pub fn renderLiteralSuffix(ctype: CType, bw: *Writer, pool: *const Pool) Writer.
280280 .short,
281281 .int,
282282 => {},
283 .long => try bw.writeByte('l'),
284 .@"long long" => try bw.writeAll("ll"),
283 .long => try w.writeByte('l'),
284 .@"long long" => try w.writeAll("ll"),
285285 .@"unsigned char",
286286 .@"unsigned short",
287287 .@"unsigned int",
288 => try bw.writeByte('u'),
288 => try w.writeByte('u'),
289289 .@"unsigned long",
290290 .size_t,
291291 .uintptr_t,
292 => try bw.writeAll("ul"),
293 .@"unsigned long long" => try bw.writeAll("ull"),
294 .float => try bw.writeByte('f'),
292 => try w.writeAll("ul"),
293 .@"unsigned long long" => try w.writeAll("ull"),
294 .float => try w.writeByte('f'),
295295 .double => {},
296 .@"long double" => try bw.writeByte('l'),
296 .@"long double" => try w.writeByte('l'),
297297 .bool,
298298 .ptrdiff_t,
299299 .intptr_t,
......@@ -314,11 +314,11 @@ pub fn renderLiteralSuffix(ctype: CType, bw: *Writer, pool: *const Pool) Writer.
314314 .zig_f80,
315315 .zig_f128,
316316 .zig_c_longdouble,
317 => try bw.writeByte(')'),
317 => try w.writeByte(')'),
318318 .va_list => unreachable,
319319 _ => unreachable,
320320 },
321 .array, .vector => try bw.writeByte('}'),
321 .array, .vector => try w.writeByte('}'),
322322 else => unreachable,
323323 }
324324}
......@@ -938,18 +938,13 @@ pub const Pool = struct {
938938 index: String.Index,
939939
940940 const FormatData = struct { string: String, pool: *const Pool };
941 fn format(
942 data: FormatData,
943 bw: *Writer,
944 comptime fmt_str: []const u8,
945 ) Writer.Error!void {
946 comptime assert(fmt_str.len == 0);
941 fn format(data: FormatData, writer: *Writer) Writer.Error!void {
947942 if (data.string.toSlice(data.pool)) |slice|
948 try bw.writeAll(slice)
943 try writer.writeAll(slice)
949944 else
950 try bw.print("f{d}", .{@intFromEnum(data.string.index)});
945 try writer.print("f{d}", .{@intFromEnum(data.string.index)});
951946 }
952 pub fn fmt(str: String, pool: *const Pool) std.fmt.Formatter(format) {
947 pub fn fmt(str: String, pool: *const Pool) std.fmt.Formatter(FormatData, format) {
953948 return .{ .data = .{ .string = str, .pool = pool } };
954949 }
955950
src/codegen/llvm.zig+4-2
......@@ -2491,7 +2491,7 @@ pub const Object = struct {
24912491 var union_name_buf: ?[:0]const u8 = null;
24922492 defer if (union_name_buf) |buf| gpa.free(buf);
24932493 const union_name = if (layout.tag_size == 0) name else name: {
2494 union_name_buf = try std.fmt.allocPrintZ(gpa, "{s}:Payload", .{name});
2494 union_name_buf = try std.fmt.allocPrintSentinel(gpa, "{s}:Payload", .{name}, 0);
24952495 break :name union_name_buf.?;
24962496 };
24972497
......@@ -2687,7 +2687,9 @@ pub const Object = struct {
26872687 fn allocTypeName(o: *Object, ty: Type) Allocator.Error![:0]const u8 {
26882688 var aw: std.io.Writer.Allocating = .init(o.gpa);
26892689 defer aw.deinit();
2690 ty.print(&aw.interface, o.pt) catch return error.OutOfMemory;
2690 ty.print(&aw.writer, o.pt) catch |err| switch (err) {
2691 error.WriteFailed => return error.OutOfMemory,
2692 };
26912693 return aw.toOwnedSliceSentinel(0);
26922694 }
26932695