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

package/std/math/big/int.zig

@@ -628,12 +628,12 @@ pub const Mutable = struct {
 
         // Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine
         // if an overflow occurred.
-        const x = Const{
+        const x: Const = .{
             .positive = a.positive,
             .limbs = a.limbs[0..@min(req_limbs, a.limbs.len)],
         };
 
-        const y = Const{
+        const y: Const = .{
             .positive = b.positive,
             .limbs = b.limbs[0..@min(req_limbs, b.limbs.len)],
         };
@@ -647,9 +647,8 @@ pub const Mutable = struct {
             //   Note: after this we still might need to wrap.
             const msl = @max(a.limbs.len, b.limbs.len);
             if (msl < req_limbs) {
+                r.len = msl + 1;
                 r.limbs[msl] = 1;
-                r.len = req_limbs;
-                @memset(r.limbs[msl + 1 .. req_limbs], 0);
             } else {
                 carry_truncated = true;
             }
@@ -673,12 +672,12 @@ pub const Mutable = struct {
 
         // Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine
         // if an overflow occurred.
-        const x = Const{
+        const x: Const = .{
             .positive = a.positive,
             .limbs = a.limbs[0..@min(req_limbs, a.limbs.len)],
         };
 
-        const y = Const{
+        const y: Const = .{
             .positive = b.positive,
             .limbs = b.limbs[0..@min(req_limbs, b.limbs.len)],
         };
@@ -690,12 +689,12 @@ pub const Mutable = struct {
             //   Note: In this case, might _also_ need to saturate.
             const msl = @max(a.limbs.len, b.limbs.len);
             if (msl < req_limbs) {
+                r.len = msl + 1;
                 r.limbs[msl] = 1;
-                r.len = req_limbs;
                 // Note: Saturation may still be required if msl == req_limbs - 1
             } else {
                 // Overflowed req_limbs, definitely saturate.
-                r.setTwosCompIntLimit(if (r.positive) .max else .min, signedness, bit_count);
+                return r.setTwosCompIntLimit(if (r.positive) .max else .min, signedness, bit_count);
             }
         }
 
@@ -1374,7 +1373,7 @@ pub const Mutable = struct {
     /// r is `calcTwosCompLimbCount(bit_count)`.
     pub fn bitNotWrap(r: *Mutable, a: Const, signedness: Signedness, bit_count: usize) void {
         r.copy(a.negate());
-        const negative_one = Const{ .limbs = &.{1}, .positive = false };
+        const negative_one: Const = .{ .limbs = &.{1}, .positive = false };
         _ = r.addWrap(r.toConst(), negative_one, signedness, bit_count);
     }
 
@@ -1740,13 +1739,13 @@ pub const Mutable = struct {
             r.positive = r_positive;
         } else {
             // Shrink x, y such that the trailing zero limbs shared between are removed.
-            var x0 = Mutable{
+            var x0: Mutable = .{
                 .limbs = x.limbs[xy_trailing..],
                 .len = x.len - xy_trailing,
                 .positive = true,
             };
 
-            var y0 = Mutable{
+            var y0: Mutable = .{
                 .limbs = y.limbs[xy_trailing..],
                 .len = y.len - xy_trailing,
                 .positive = true,
@@ -1809,7 +1808,7 @@ pub const Mutable = struct {
             // x >= y * b^(n - t) can be replaced by x/b^(n - t) >= y.
 
             // 'divide' x by b^(n - t)
-            var tmp = Mutable{
+            var tmp: Mutable = .{
                 .limbs = x.limbs[shift..],
                 .len = x.len - shift,
                 .positive = true,
@@ -2108,7 +2107,7 @@ pub const Const = struct {
     pub fn toManaged(self: Const, allocator: Allocator) Allocator.Error!Managed {
         const limbs = try allocator.alloc(Limb, @max(Managed.default_capacity, self.limbs.len));
         @memcpy(limbs[0..self.limbs.len], self.limbs);
-        return Managed{
+        return .{
             .allocator = allocator,
             .limbs = limbs,
             .metadata = if (self.positive)
@@ -2802,7 +2801,7 @@ pub const Managed = struct {
     /// default capacity will be used instead.
     /// The integer value after initializing is `0`.
     pub fn initCapacity(allocator: Allocator, capacity: usize) !Managed {
-        return Managed{
+        return .{
             .allocator = allocator,
             .metadata = 1,
             .limbs = block: {
@@ -2868,7 +2867,7 @@ pub const Managed = struct {
     }
 
     pub fn cloneWithDifferentAllocator(other: Managed, allocator: Allocator) !Managed {
-        return Managed{
+        return .{
             .allocator = allocator,
             .metadata = other.metadata,
             .limbs = block: {
@@ -3454,7 +3453,7 @@ pub const Managed = struct {
             const tmp = try rma.allocator.alloc(Limb, a_len);
             defer rma.allocator.free(tmp);
             @memcpy(tmp[0..a_len], a.limbs[0..a_len]);
-            const a_const = Const{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
+            const a_const: Const = .{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
             var rma_mut = rma.toMutable();
             rma_mut.sqrNoAlias(a_const, rma.allocator);
             rma.setMetadata(rma_mut.positive, rma_mut.len);
@@ -3479,7 +3478,7 @@ pub const Managed = struct {
             const tmp = try rma.allocator.alloc(Limb, a_len);
             defer rma.allocator.free(tmp);
             @memcpy(tmp[0..a_len], a.limbs[0..a_len]);
-            const a_const = Const{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
+            const a_const: Const = .{ .limbs = tmp[0..a_len], .positive = a.isPositive() };
             var rma_mut = rma.toMutable();
             rma_mut.pow(a_const, b, limbs_buffer);
             rma.setMetadata(rma_mut.positive, rma_mut.len);

package/std/mem/Allocator.zig

@@ -322,7 +322,7 @@ pub fn resize(self: Allocator, allocation: anytype, new_len: usize) bool {
     if (allocation.len == 0) {
         return false;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -368,7 +368,7 @@ pub fn remap(self: Allocator, allocation: anytype, new_len: usize) ?@TypeOf(allo
         new_memory.len = new_len;
         return new_memory;
     }
-    const old_memory = mem.sliceAsBytes(allocation);
+    const old_memory: []u8 = @ptrCast(@constCast(mem.absorbSentinel(allocation)));
     // I would like to use saturating multiplication here, but LLVM cannot lower it
     // on WebAssembly: https://github.com/ziglang/zig/issues/9660
     //const new_len_bytes = new_len *| @sizeOf(T);
@@ -420,7 +420,7 @@ pub fn reallocAdvanced(
         return ptr;
     }
 
-    const old_byte_slice = mem.sliceAsBytes(old_mem);
+    const old_byte_slice: []u8 = @ptrCast(@constCast(mem.absorbSentinel(old_mem)));
     const byte_count = math.mul(usize, @sizeOf(T), new_n) catch return error.OutOfMemory;
     // Note: can't set shrunk memory to undefined as memory shouldn't be modified on realloc failure
     if (self.rawRemap(old_byte_slice, .fromByteUnits(slice_info.alignment orelse @alignOf(T)), byte_count, return_address)) |p| {
@@ -443,8 +443,7 @@ pub fn reallocAdvanced(
 pub fn free(self: Allocator, memory: anytype) void {
     const slice_info = @typeInfo(@TypeOf(memory)).pointer;
     comptime assert(slice_info.size == .slice);
-    const mem_with_sent = memory[0 .. memory.len + @intFromBool(slice_info.sentinel() != null)];
-    const bytes: []u8 = @ptrCast(@constCast(mem_with_sent));
+    const bytes: []u8 = @ptrCast(@constCast(mem.absorbSentinel(memory)));
     if (bytes.len == 0) return;
     @memset(bytes, undefined);
     self.rawFree(bytes, .fromByteUnits(slice_info.alignment orelse @alignOf(slice_info.child)), @returnAddress());

package/std/mem.zig

@@ -4709,6 +4709,54 @@ test "sliceAsBytes preserves pointer attributes" {
     try testing.expectEqual(in.alignment, out.alignment);
 }
 
+fn AbsorbSentinelReturnType(comptime Slice: type) type {
+    const info = @typeInfo(Slice).pointer;
+    assert(info.size == .slice);
+    return @Pointer(.slice, .{
+        .@"const" = info.is_const,
+        .@"volatile" = info.is_volatile,
+        .@"allowzero" = info.is_allowzero,
+        .@"addrspace" = info.address_space,
+        .@"align" = info.alignment,
+    }, info.child, null);
+}
+
+/// If the provided slice is not sentinel terminated, do nothing and return that slice.
+/// If it is sentinel-terminated, return a non-sentinel-terminated slice with the
+/// length increased by one to include the absorbed sentinel element.
+pub fn absorbSentinel(slice: anytype) AbsorbSentinelReturnType(@TypeOf(slice)) {
+    const info = @typeInfo(@TypeOf(slice)).pointer;
+    comptime assert(info.size == .slice);
+    if (info.sentinel_ptr == null) {
+        return slice;
+    } else {
+        return slice.ptr[0 .. slice.len + 1];
+    }
+}
+
+test absorbSentinel {
+    {
+        var buffer: [3:0]u8 = .{ 1, 2, 3 };
+        const foo: [:0]const u8 = &buffer;
+        const bar: []const u8 = &buffer;
+        try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(foo)));
+        try testing.expectEqual([]const u8, @TypeOf(absorbSentinel(bar)));
+        try testing.expectEqualSlices(u8, &.{ 1, 2, 3, 0 }, absorbSentinel(foo));
+        try testing.expectEqualSlices(u8, &.{ 1, 2, 3 }, absorbSentinel(bar));
+    }
+    {
+        var buffer: [3:0]u8 = .{ 1, 2, 3 };
+        const foo: [:0]u8 = &buffer;
+        const bar: []u8 = &buffer;
+        try testing.expectEqual([]u8, @TypeOf(absorbSentinel(foo)));
+        try testing.expectEqual([]u8, @TypeOf(absorbSentinel(bar)));
+        var expected_foo = [_]u8{ 1, 2, 3, 0 };
+        try testing.expectEqualSlices(u8, &expected_foo, absorbSentinel(foo));
+        var expected_bar = [_]u8{ 1, 2, 3 };
+        try testing.expectEqualSlices(u8, &expected_bar, absorbSentinel(bar));
+    }
+}
+
 /// Round an address down to the next (or current) aligned address.
 /// Unlike `alignForward`, `alignment` can be any positive number, not just a power of 2.
 pub fn alignForwardAnyAlign(comptime T: type, addr: T, alignment: T) T {

package/std/os/emscripten.zig

@@ -11,22 +11,6 @@ const c = std.c;
 
 pub const FILE = c.FILE;
 
-var __stack_chk_guard: usize = 0;
-fn __stack_chk_fail() callconv(.c) void {
-    std.debug.print("stack smashing detected: terminated\n", .{});
-    emscripten_force_exit(127);
-}
-
-comptime {
-    if (builtin.os.tag == .emscripten) {
-        if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) {
-            // Emscripten does not provide these symbols, so we must export our own
-            @export(&__stack_chk_guard, .{ .name = "__stack_chk_guard", .linkage = .strong });
-            @export(&__stack_chk_fail, .{ .name = "__stack_chk_fail", .linkage = .strong });
-        }
-    }
-}
-
 pub const PF = linux.PF;
 pub const AF = linux.AF;
 pub const CLOCK = linux.CLOCK;
@@ -227,8 +211,8 @@ pub const W = struct {
     pub fn TERMSIG(s: u32) SIG {
         return @enumFromInt(s & 0x7f);
     }
-    pub fn STOPSIG(s: u32) u32 {
-        return EXITSTATUS(s);
+    pub fn STOPSIG(s: u32) SIG {
+        return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {
         return (s & 0x7f) == 0;

package/std/os/linux/arc.zig

@@ -0,0 +1,144 @@
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+        : .{ .memory = true });
+}
+
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+        : .{ .memory = true });
+}
+
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+        : .{ .memory = true });
+}
+
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+        : .{ .memory = true });
+}
+
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+        : .{ .memory = true });
+}
+
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+        : .{ .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    return asm volatile ("trap_s 0"
+        : [ret] "={r0}" (-> u32),
+        : [number] "{r8}" (@intFromEnum(number)),
+          [arg1] "{r0}" (arg1),
+          [arg2] "{r1}" (arg2),
+          [arg3] "{r2}" (arg3),
+          [arg4] "{r3}" (arg4),
+          [arg5] "{r4}" (arg5),
+          [arg6] "{r5}" (arg6),
+        : .{ .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         r0,   r1,    r2,    r3,  r4,   r5,  r6
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         r8         r0,    r1,    r2,   r3,  r4
+    asm volatile (
+        \\    // Align stack pointer
+        \\    and r1, r1, -16
+        \\    mov r10, r0
+        \\    mov r11, r3
+        \\    // Setup the arguments
+        \\    mov r0, r2
+        \\    mov r2, r4
+        \\    mov r3, r5
+        \\    mov r4, r6
+        \\    mov r8, 220 // SYS_clone
+        \\    trap_s 0
+        \\    cmp r0, 0
+        \\    beq 1f
+        \\    j [blink]
+        \\    // Child
+        \\ 1: 
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined blink
+    );
+
+    asm volatile (
+        \\    mov fp, 0
+        \\    mov blink, 0
+        \\
+        \\    mov r0, r11
+        \\    jl [r10]
+        \\
+        \\    // Exit
+        \\    mov r8, 93 // SYS_exit
+        \\    trap_s 0
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    switch (builtin.zig_backend) {
+        .stage2_c => asm volatile (
+            \\ mov r8, %[number]
+            \\ trap_s 0
+            :
+            : [number] "I" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+        else => asm volatile (
+            \\ trap_s 0
+            :
+            : [number] "{r8}" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+    }
+}
+
+pub const time_t = i64;
+
+pub const VDSO = void;

package/std/os/linux.zig

@@ -31,6 +31,7 @@ test {
 
 const arch_bits = switch (native_arch) {
     .aarch64, .aarch64_be => @import("linux/aarch64.zig"),
+    .arc, .arceb => @import("linux/arc.zig"),
     .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
     .hexagon => @import("linux/hexagon.zig"),
     .loongarch32 => @import("linux/loongarch32.zig"),
@@ -274,7 +275,13 @@ pub const MAP = switch (native_arch) {
         UNINITIALIZED: bool = false,
         _: u5 = 0,
     },
-    .hexagon, .m68k, .or1k, .s390x => packed struct(u32) {
+    .arc,
+    .arceb,
+    .hexagon,
+    .m68k,
+    .or1k,
+    .s390x,
+    => packed struct(u32) {
         TYPE: MAP_TYPE,
         FIXED: bool = false,
         ANONYMOUS: bool = false,
@@ -451,7 +458,12 @@ pub const O = switch (native_arch) {
         TMPFILE: bool = false,
         _23: u9 = 0,
     },
-    .hexagon, .or1k, .s390x => packed struct(u32) {
+    .arc,
+    .arceb,
+    .hexagon,
+    .or1k,
+    .s390x,
+    => packed struct(u32) {
         ACCMODE: ACCMODE = .RDONLY,
         _2: u4 = 0,
         CREAT: bool = false,
@@ -1584,6 +1596,11 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
     return syscall2(.clone, flags, child_stack_ptr);
 }
 
+/// This call cannot fail, and the return value is the caller's thread id
+pub fn set_tid_address(tidptr: ?*pid_t) pid_t {
+    return @intCast(@as(u32, @truncate(syscall1(.set_tid_address, @intFromPtr(tidptr)))));
+}
+
 pub fn close(fd: fd_t) usize {
     return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
 }
@@ -3878,8 +3895,8 @@ pub const W = struct {
     pub fn TERMSIG(s: u32) SIG {
         return @enumFromInt(s & 0x7f);
     }
-    pub fn STOPSIG(s: u32) u32 {
-        return EXITSTATUS(s);
+    pub fn STOPSIG(s: u32) SIG {
+        return @enumFromInt(EXITSTATUS(s));
     }
     pub fn IFEXITED(s: u32) bool {
         return (s & 0x7f) == 0;

package/std/os/windows.zig

@@ -3952,7 +3952,7 @@ inline fn MAKELANGID(p: c_ushort, s: c_ushort) LANGID {
 /// and you get an unexpected error.
 pub fn unexpectedError(err: Win32Error) UnexpectedError {
     @branchHint(.cold);
-    if (std.posix.unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("error.Unexpected: GetLastError({d}): {t}\n", .{ err, err });
         std.debug.dumpCurrentStackTrace(.{ .first_address = @returnAddress() });
     }
@@ -3962,7 +3962,7 @@ pub fn unexpectedError(err: Win32Error) UnexpectedError {
 /// Call this when you made a windows NtDll call
 /// and you get an unexpected status.
 pub fn unexpectedStatus(status: NTSTATUS) UnexpectedError {
-    if (std.posix.unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("error.Unexpected NTSTATUS=0x{x} ({s})\n", .{
             @intFromEnum(status),
             std.enums.tagName(NTSTATUS, status) orelse "<unnamed>",

package/std/pdb.zig

@@ -314,11 +314,9 @@ pub const SymbolKind = enum(u16) {
 
 pub const TypeIndex = u32;
 
-// TODO According to this header:
-// https://github.com/microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/include/cvinfo.h#L3722
-// we should define RecordPrefix as part of the ProcSym structure.
-// This might be important when we start generating PDB in self-hosted with our own PE linker.
 pub const ProcSym = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
     parent: u32,
     end: u32,
     next: u32,
@@ -508,3 +506,144 @@ pub const SuperBlock = extern struct {
     // implement it so we're kind of safe making this assumption for now.
     block_map_addr: u32,
 };
+
+pub const IpiStreamVersion = enum(u32) {
+    v40 = 19950410,
+    v41 = 19951122,
+    v50 = 19961031,
+    v70 = 19990903,
+    v80 = 20040203,
+    _,
+};
+
+pub const IpiStreamHeader = extern struct {
+    version: IpiStreamVersion,
+    header_size: u32,
+    type_index_begin: u32,
+    type_index_end: u32,
+    type_record_bytes: u32,
+    hash_stream_index: u16,
+    hash_aux_stream_index: u16,
+    hash_key_size: u32,
+    num_hash_buckets: u32,
+    hash_value_buffer_offset: i32,
+    hash_value_buffer_length: u32,
+    index_offset_buffer_offset: i32,
+    index_offset_buffer_length: u32,
+    hash_adj_buffer_offset: i32,
+    hash_adj_buffer_length: u32,
+};
+
+pub const LfRecordPrefix = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+};
+
+pub const LfRecordKind = enum(u16) {
+    pointer = 0x1002,
+    modifier = 0x1001,
+    procedure = 0x1008,
+    mfunction = 0x1009,
+    label = 0x000e,
+    arglist = 0x1201,
+    fieldlist = 0x1203,
+    array = 0x1503,
+    class = 0x1504,
+    structure = 0x1505,
+    interface = 0x1519,
+    @"union" = 0x1506,
+    @"enum" = 0x1507,
+    typeserver2 = 0x1515,
+    vftable = 0x151d,
+    vtshape = 0x000a,
+    bitfield = 0x1205,
+    func_id = 0x1601,
+    mfunc_id = 0x1602,
+    buildinfo = 0x1603,
+    substr_list = 0x1604,
+    string_id = 0x1605,
+    udt_src_line = 0x1606,
+    udt_mod_src_line = 0x1607,
+    methodlist = 0x1206,
+    precomp = 0x1509,
+    endprecomp = 0x0014,
+    bclass = 0x1400,
+    binterface = 0x151a,
+    vbclass = 0x1401,
+    ivbclass = 0x1402,
+    vfunctab = 0x1409,
+    stmember = 0x150e,
+    method = 0x150f,
+    member = 0x150d,
+    nesttype = 0x1510,
+    onemethod = 0x1511,
+    enumerate = 0x1502,
+    index = 0x1404,
+    pad0 = 0xf0,
+    _,
+};
+
+pub const LfFuncId = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+    scope_id: u32,
+    type: u32,
+    name: [1]u8, // null-terminated
+};
+
+pub const LfMFuncId = extern struct {
+    len: u16,
+    kind: LfRecordKind,
+    parent_type: u32,
+    type: u32,
+    name: [1]u8, // null-terminated
+};
+
+pub const InlineSiteSym = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
+    parent: u32,
+    end: u32,
+    inlinee: u32,
+};
+
+pub const InlineSiteSym2 = extern struct {
+    record_len: u16,
+    record_kind: SymbolKind,
+    parent: u32,
+    end: u32,
+    inlinee: u32,
+    invocations: u32,
+};
+
+pub const InlineeSourceLineSignature = enum(u32) { normal = 0, ex = 1, _ };
+
+pub const InlineeSourceLine = extern struct {
+    inlinee: u32,
+    file_id: u32,
+    source_line_num: u32,
+};
+
+pub const InlineeSourceLineEx = extern struct {
+    inlinee: u32,
+    file_id: u32,
+    source_line_num: u32,
+    count_of_extra_files: u32,
+};
+
+pub const BinaryAnnotationOpcode = enum(u8) {
+    invalid = 0,
+    code_offset = 1,
+    change_code_offset_base = 2,
+    change_code_offset = 3,
+    change_code_length = 4,
+    change_file = 5,
+    change_line_offset = 6,
+    change_line_end_delta = 7,
+    change_range_kind = 8,
+    change_column_start = 9,
+    change_column_end_delta = 10,
+    change_code_offset_and_line_offset = 11,
+    change_code_length_and_code_offset = 12,
+    change_column_end = 13,
+};

package/std/posix.zig

@@ -513,6 +513,9 @@ pub const GetSockNameError = error{
     SocketNotBound,
 
     FileDescriptorNotASocket,
+
+    /// The socket is not connected (connection-oriented sockets only).
+    SocketUnconnected,
 } || UnexpectedError;
 
 pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSockNameError!void {
@@ -529,6 +532,7 @@ pub fn getpeername(sock: socket_t, addr: *sockaddr, addrlen: *socklen_t) GetSock
             .INVAL => unreachable, // invalid parameters
             .NOTSOCK => return error.FileDescriptorNotASocket,
             .NOBUFS => return error.SystemResources,
+            .NOTCONN => return error.SocketUnconnected,
         }
     }
 }
@@ -682,7 +686,7 @@ pub fn munmap(memory: []align(page_size_min) const u8) void {
         .SUCCESS => return,
         .INVAL => unreachable, // Invalid parameters.
         .NOMEM => unreachable, // Attempted to unmap a region in the middle of an existing mapping.
-        else => |e| if (unexpected_error_tracing) {
+        else => |e| if (std.options.unexpected_error_tracing) {
             std.debug.panic("unexpected errno: {d} ({t})", .{ @intFromEnum(e), e });
         } else unreachable,
     }
@@ -1658,22 +1662,12 @@ pub fn name_to_handle_atZ(
 
 pub const lfs64_abi = native_os == .linux and builtin.link_libc and (builtin.abi.isGnu() or builtin.abi.isAndroid());
 
-/// Whether or not `error.Unexpected` will print its value and a stack trace.
-///
-/// If this happens the fix is to add the error code to the corresponding
-/// switch expression, possibly introduce a new error in the error set, and
-/// send a patch to Zig.
-pub const unexpected_error_tracing = builtin.mode == .Debug and switch (builtin.zig_backend) {
-    .stage2_llvm, .stage2_x86_64 => true,
-    else => false,
-};
-
 pub const UnexpectedError = std.Io.UnexpectedError;
 
 /// Call this when you made a syscall or something that sets errno
 /// and you get an unexpected error.
 pub fn unexpectedErrno(err: E) UnexpectedError {
-    if (unexpected_error_tracing) {
+    if (std.options.unexpected_error_tracing) {
         std.debug.print("unexpected errno: {d}\n", .{@intFromEnum(err)});
         std.debug.dumpCurrentStackTrace(.{});
     }