srctree

llvm_linkage: std.Build.Step.Compile.Linkage,

@setFloatMode(.Optimized);

@export(internalName, .{ .name = "foo", .linkage = .Strong });

switch (@atomicLoad(Step.State, &dep.state, .SeqCst)) {

@atomicStore(Step.State, &s.state, .dependency_failure, .SeqCst);

if (@cmpxchgStrong(Step.State, &s.state, .precheck_done, .running, .SeqCst, .SeqCst) != null) {

@atomicStore(Step.State, &s.state, .success, .SeqCst);

@atomicStore(Step.State, &s.state, .failure, .SeqCst);

error.MakeSkipped => @atomicStore(Step.State, &s.state, .skipped, .SeqCst),

@export(wasm_start, .{ .name = "_start", .linkage = .Strong });

@export(strcmp, .{ .name = "strcmp", .linkage = .Strong });

@export(strncmp, .{ .name = "strncmp", .linkage = .Strong });

@export(strerror, .{ .name = "strerror", .linkage = .Strong });

@export(strlen, .{ .name = "strlen", .linkage = .Strong });

@export(strcpy, .{ .name = "strcpy", .linkage = .Strong });

@export(strncpy, .{ .name = "strncpy", .linkage = .Strong });

@export(strcat, .{ .name = "strcat", .linkage = .Strong });

@export(strncat, .{ .name = "strncat", .linkage = .Strong });

@export(_fltused, .{ .name = "_fltused", .linkage = .Strong });

.layout = .Auto,

break :flag @atomicRmw(@TypeOf(self.v), &self.v, .Xchg, .Locked, .Acquire);

@atomicStore(@TypeOf(self.v), &self.v, .Unlocked, .Release);

return @atomicLoad(T, src, .SeqCst);

@atomicStore(T, dst, value, .SeqCst);

var wide_old = @atomicLoad(WideAtomic, wide_ptr, .SeqCst);

if (@cmpxchgWeak(WideAtomic, wide_ptr, wide_old, wide_new, .SeqCst, .SeqCst)) |new_wide_old| {

return @atomicRmw(T, ptr, .Xchg, val, .SeqCst);

if (@cmpxchgStrong(T, ptr, expected.*, desired, .SeqCst, .SeqCst)) |old_value| {

return @atomicRmw(T, ptr, op, val, .SeqCst);

const linkage = if (builtin.is_test) std.builtin.GlobalLinkage.Internal else std.builtin.GlobalLinkage.Weak;

pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;

if (builtin.target.isWasm() and linkage != .Internal) .hidden else .default;

const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;

const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;

const strong_linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Strong;

linkage: ?Step.Compile.Linkage = null,

preferred_link_mode: std.builtin.LinkMode = .Dynamic,

linkage: ?Linkage = null,

linkage: ?Linkage = null,

pub const Linkage = enum { dynamic, static };

 

.link_mode = if (options.linkage) |some| @as(std.builtin.LinkMode, switch (some) {

.dynamic => .Dynamic,

.static => .Static,

}) else null,

return self.kind == .lib and self.linkage == Linkage.dynamic;

return self.kind == .lib and self.linkage != Linkage.dynamic;

var prev_preferred_link_mode: std.builtin.LinkMode = .Dynamic;

.Dynamic => try zig_args.append("-search_dylibs_only"),

.Static => try zig_args.append("-search_static_only"),

.Dynamic => try zig_args.append("-search_paths_first"),

.Static => try zig_args.append("-search_paths_first_static"),

.Dynamic => try zig_args.append("-search_dylibs_first"),

.Static => try zig_args.append("-search_static_first"),

if (other.linkage == Linkage.dynamic and

linkage: ?Step.Compile.Linkage = null,

@atomicStore(?*Node, &parent.recently_updated_child, self, .Release);

_ = @atomicRmw(usize, &self.unprotected_completed_items, .Add, 1, .Monotonic);

_ = @cmpxchgStrong(?*Node, &parent.recently_updated_child, self, null, .Monotonic, .Monotonic);

@atomicStore(?*Node, &parent.recently_updated_child, self, .Release);

@atomicStore(?*Node, &parent.recently_updated_child, self, .Release);

@atomicStore(?*Node, &grand_parent.recently_updated_child, parent, .Release);

@atomicStore(?*Node, &parent.recently_updated_child, self, .Release);

@atomicStore(?*Node, &grand_parent.recently_updated_child, parent, .Release);

@atomicStore(usize, &self.unprotected_estimated_total_items, count, .Monotonic);

@atomicStore(usize, &self.unprotected_completed_items, completed_items, .Monotonic);

const eti = @atomicLoad(usize, &node.unprotected_estimated_total_items, .Monotonic);

const completed_items = @atomicLoad(usize, &node.unprotected_completed_items, .Monotonic);

maybe_node = @atomicLoad(?*Node, &node.recently_updated_child, .Acquire);

defer switch (self.thread.completion.swap(.completed, .SeqCst)) {

switch (self.thread.completion.swap(.detached, .SeqCst)) {

assert(self.thread.completion.load(.SeqCst) == .completed);

return self.thread.tid.load(.SeqCst);

switch (self.thread.state.swap(.detached, .SeqCst)) {

const tid = self.thread.tid.load(.SeqCst);

instance.thread.tid.store(tid, .SeqCst);

@atomicStore(u32, &WasiThreadImpl.tls_thread_id, @intCast(tid), .SeqCst);

switch (arg.thread.state.swap(.completed, .SeqCst)) {

defer switch (self.thread.completion.swap(.completed, .SeqCst)) {

switch (self.thread.completion.swap(.detached, .SeqCst)) {

const tid = self.thread.child_tid.load(.SeqCst);

mutex.impl.locking_thread.store(0, .Unordered);

mutex.impl.locking_thread.store(std.Thread.getCurrentId(), .Unordered);

var epoch = self.epoch.load(.Acquire);

var state = self.state.fetchAdd(one_waiter, .Monotonic);

state = self.state.cmpxchgWeak(state, new_state, .Acquire, .Monotonic) orelse return;

state = self.state.cmpxchgWeak(state, new_state, .Monotonic, .Monotonic) orelse return err;

epoch = self.epoch.load(.Acquire);

state = self.state.load(.Monotonic);

state = self.state.cmpxchgWeak(state, new_state, .Acquire, .Monotonic) orelse return;

var state = self.state.load(.Monotonic);

state = self.state.cmpxchgWeak(state, new_state, .Release, .Monotonic) orelse {

_ = self.epoch.fetchAdd(1, .Release);

if (ptr.load(.SeqCst) != expect) return;

// SeqCst as Acquire barrier to ensure the announcement happens before the ptr check below.

// SeqCst as shared modification order to form a happens-before edge with the fence(.SeqCst)+load() in wake().

var pending = bucket.pending.fetchAdd(1, .SeqCst);

pending = bucket.pending.fetchSub(1, .Monotonic);

// fence(SeqCst) effectively converts the ptr update to SeqCst and the pending load to SeqCst: creating a Store-Load barrier.

// The pending count increment in wait() must also now use SeqCst for the update + this pending load

// to be in the same modification order as our load isn't using Release/Acquire to guarantee it.

bucket.pending.fence(.SeqCst);

_ = self.value.fetchAdd(1, .Release);

new_value = self.value.load(.Acquire);

const count = self.count.fetchSub(1, .Release);

_ = self.count.load(.Acquire); // TODO: could be fence(Acquire) if not for TSAN

self.futex.store(1, .Release);

while (self.futex.load(.Acquire) == 0) {

self.locking_thread.store(Thread.getCurrentId(), .Unordered);

if (self.locking_thread.load(.Unordered) == current_id and current_id != 0) {

self.locking_thread.store(current_id, .Unordered);

assert(self.locking_thread.load(.Unordered) == Thread.getCurrentId());

self.locking_thread.store(0, .Unordered);

return self.state.bitSet(locked_bit, .Acquire) == 0;

return self.state.cmpxchgWeak(unlocked, locked, .Acquire, .Monotonic) == null;

if (self.state.load(.Monotonic) == contended) {

while (self.state.swap(contended, .Acquire) != unlocked) {

const state = self.state.swap(unlocked, .Release);

return self.state.load(.Acquire) == is_set;

var state = self.state.load(.Monotonic);

state = self.state.cmpxchgStrong(state, waiting, .Monotonic, .Monotonic) orelse waiting;

state = self.state.load(.Monotonic);

self.state.fence(.Acquire);

if (self.state.load(.Monotonic) == is_set) {

if (self.state.swap(is_set, .Release) == waiting) {

self.state.store(unset, .Monotonic);

if (self.counter.fetchSub(1, .AcqRel) == 1) {

const state = @atomicLoad(usize, &rwl.state, .SeqCst);

_ = @atomicRmw(usize, &rwl.state, .Or, IS_WRITING, .SeqCst);

_ = @atomicRmw(usize, &rwl.state, .Add, WRITER, .SeqCst);

const state = @atomicRmw(usize, &rwl.state, .Add, IS_WRITING -% WRITER, .SeqCst);

_ = @atomicRmw(usize, &rwl.state, .And, ~IS_WRITING, .SeqCst);

const state = @atomicLoad(usize, &rwl.state, .SeqCst);

.SeqCst,

.SeqCst,

_ = @atomicRmw(usize, &rwl.state, .Add, READER, .SeqCst);

var state = @atomicLoad(usize, &rwl.state, .SeqCst);

.SeqCst,

.SeqCst,

_ = @atomicRmw(usize, &rwl.state, .Add, READER, .SeqCst);

const state = @atomicRmw(usize, &rwl.state, .Sub, READER, .SeqCst);

if (self.writes >= num_writes or self.reads.load(.Unordered) >= num_reads)

_ = self.reads.fetchAdd(1, .Monotonic);

const state = self.state.fetchAdd(one_pending, .Monotonic);

const state = self.state.fetchSub(one_pending, .Release);

self.state.fence(.Acquire);

const state = self.state.fetchAdd(is_waiting, .Acquire);

self.state.store(0, .Monotonic);

const state = wg.state.load(.Acquire);

.Unordered, .Monotonic => @compileError(@tagName(order) ++ " only applies to atomic loads and stores"),

.Acquire => tsan.__tsan_acquire(addr),

.Release => tsan.__tsan_release(addr),

.AcqRel, .SeqCst => {

_ = rc.count.fetchAdd(1, .Monotonic);

if (rc.count.fetchSub(1, .Release) == 1) {

// Acquire ensures count decrement and code before

rc.count.fence(.Acquire);

try testing.expectEqual(@as(usize, 5), x.swap(10, .SeqCst));

try testing.expectEqual(@as(usize, 10), x.load(.SeqCst));

try testing.expectEqual(E.c, y.swap(.a, .SeqCst));

try testing.expectEqual(E.a, y.load(.SeqCst));

try testing.expectEqual(@as(f32, 5.0), z.swap(10.0, .SeqCst));

try testing.expectEqual(@as(f32, 10.0), z.load(.SeqCst));

try testing.expectEqual(false, a.swap(true, .SeqCst));

try testing.expectEqual(true, a.load(.SeqCst));

try testing.expectEqual(@as(?*u8, null), b.swap(@as(?*u8, @ptrFromInt(@alignOf(u8))), .SeqCst));

try testing.expectEqual(@as(?*u8, @ptrFromInt(@alignOf(u8))), b.load(.SeqCst));

x.store(10, .SeqCst);

try testing.expectEqual(@as(usize, 10), x.load(.SeqCst));

try testing.expectEqual(@as(?usize, 0), x.cmpxchgWeak(1, 0, .SeqCst, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

while (x.cmpxchgWeak(0, 1, .SeqCst, .SeqCst)) |_| {}

try testing.expectEqual(@as(usize, 1), x.load(.SeqCst));

while (x.cmpxchgWeak(1, 0, .SeqCst, .SeqCst)) |_| {}

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(?usize, 0), x.cmpxchgStrong(1, 0, .SeqCst, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(?usize, null), x.cmpxchgStrong(0, 1, .SeqCst, .SeqCst));

try testing.expectEqual(@as(usize, 1), x.load(.SeqCst));

try testing.expectEqual(@as(?usize, null), x.cmpxchgStrong(1, 0, .SeqCst, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 5), x.fetchAdd(5, .SeqCst));

try testing.expectEqual(@as(usize, 10), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 10), x.fetchAdd(std.math.maxInt(usize), .SeqCst));

try testing.expectEqual(@as(usize, 9), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 5), x.fetchSub(5, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0), x.fetchSub(1, .SeqCst));

try testing.expectEqual(@as(usize, std.math.maxInt(usize)), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 5), x.fetchMin(0, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0), x.fetchMin(10, .SeqCst));

try testing.expectEqual(@as(usize, 0), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 5), x.fetchMax(10, .SeqCst));

try testing.expectEqual(@as(usize, 10), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 10), x.fetchMax(5, .SeqCst));

try testing.expectEqual(@as(usize, 10), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b11), x.fetchAnd(0b10, .SeqCst));

try testing.expectEqual(@as(usize, 0b10), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b10), x.fetchAnd(0b00, .SeqCst));

try testing.expectEqual(@as(usize, 0b00), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b11), x.fetchNand(0b10, .SeqCst));

try testing.expectEqual(~@as(usize, 0b10), x.load(.SeqCst));

try testing.expectEqual(~@as(usize, 0b10), x.fetchNand(0b00, .SeqCst));

try testing.expectEqual(~@as(usize, 0b00), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b11), x.fetchOr(0b100, .SeqCst));

try testing.expectEqual(@as(usize, 0b111), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b111), x.fetchOr(0b010, .SeqCst));

try testing.expectEqual(@as(usize, 0b111), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b11), x.fetchXor(0b10, .SeqCst));

try testing.expectEqual(@as(usize, 0b01), x.load(.SeqCst));

try testing.expectEqual(@as(usize, 0b01), x.fetchXor(0b01, .SeqCst));

try testing.expectEqual(@as(usize, 0b00), x.load(.SeqCst));

try testing.expect(x.load(.SeqCst) & mask == 0);

try testing.expectEqual(@as(u1, 0), x.bitSet(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask != 0);

try testing.expectEqual(@as(u1, 1), x.bitSet(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask != 0);

try testing.expect(x.load(.SeqCst) & prev_mask != 0);

try testing.expect(x.load(.SeqCst) & mask != 0);

try testing.expectEqual(@as(u1, 1), x.bitReset(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask == 0);

try testing.expectEqual(@as(u1, 0), x.bitReset(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask == 0);

try testing.expect(x.load(.SeqCst) & prev_mask == 0);

try testing.expect(x.load(.SeqCst) & mask == 0);

try testing.expectEqual(@as(u1, 0), x.bitToggle(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask != 0);

try testing.expectEqual(@as(u1, 1), x.bitToggle(bit, .SeqCst));

try testing.expect(x.load(.SeqCst) & mask == 0);

try testing.expect(x.load(.SeqCst) & prev_mask == 0);

Internal,

Strong,

Weak,

LinkOnce,

Unordered,

Monotonic,

Acquire,

Release,

AcqRel,

SeqCst,

Auto,

Extern,

Packed,

/// Only valid if layout is .Packed

Strict,

Optimized,

Static,

Dynamic,

linkage: GlobalLinkage = .Strong,

linkage: GlobalLinkage = .Strong,

@export(dummy_execute_header, .{ .name = "_mh_execute_header", .linkage = .Weak });

.{ windows.kernel32.GetCurrentProcessId(), pipe_name_counter.fetchAdd(1, .Monotonic) },

_ = panicking.fetchAdd(1, .SeqCst);

if (panicking.fetchSub(1, .SeqCst) != 1) {

_ = panicking.fetchAdd(1, .SeqCst);

_ = panicking.fetchAdd(1, .SeqCst);

.linux => if (!builtin.link_libc or builtin.abi == .musl and builtin.link_mode == .Static)

return @extern([*]elf.Dyn, .{ .name = "_DYNAMIC", .linkage = .Weak });

.layout = .Auto,

const optional_heap_handle = @atomicLoad(?HeapHandle, &self.heap_handle, .SeqCst);

const other_hh = @cmpxchgStrong(?HeapHandle, &self.heap_handle, null, hh, .SeqCst, .SeqCst) orelse break :blk hh;

var end_index = @atomicLoad(usize, &self.end_index, .SeqCst);

end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, .SeqCst, .SeqCst) orelse

const hint = @atomicLoad(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, .Unordered);

_ = @cmpxchgStrong(@TypeOf(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, hint, new_hint, .Monotonic, .Monotonic);

if (protocol == .tls and @atomicLoad(bool, &client.next_https_rescan_certs, .Acquire)) {

@atomicStore(bool, &client.next_https_rescan_certs, false, .Release);

.layout = .Auto,

comptime assert(@typeInfo(T).Struct.layout != .Auto);

comptime assert(@typeInfo(@TypeOf(value)).Struct.layout != .Auto);

if (struct_info.layout == .Extern) {

if (info.layout == .Extern) {

var value: T = if (struct_info.layout == .Extern) zeroes(T) else undefined;

try testing.expect(containerLayout(S1) == .Auto);

try testing.expect(containerLayout(S2) == .Packed);

try testing.expect(containerLayout(S3) == .Extern);

try testing.expect(containerLayout(U1) == .Auto);

try testing.expect(containerLayout(U2) == .Packed);

try testing.expect(containerLayout(U3) == .Extern);

.layout = .Auto,

.layout = .Auto,

.layout = .Extern,

if (@atomicLoad(bool, &self.done, .Acquire))

@atomicStore(bool, &self.done, true, .Release);

has_fchmodat2_syscall.load(.Monotonic);

has_fchmodat2_syscall.store(false, .Monotonic);

while (@cmpxchgWeak(bool, &global.abort_entered, false, true, .SeqCst, .SeqCst)) |_| {}

has_copy_file_range_syscall.load(.Monotonic)))

has_copy_file_range_syscall.store(false, .Monotonic);

@export(getauxvalImpl, .{ .name = "getauxval", .linkage = .Weak });

const ptr = @atomicLoad(?*const anyopaque, &vdso_clock_gettime, .Unordered);

@atomicStore(?*const anyopaque, &vdso_clock_gettime, ptr, .Monotonic);

const head = @atomicLoad(u32, self.sq.head, .Acquire);

@atomicStore(u32, self.sq.tail, tail, .Release);

if ((@atomicLoad(u32, self.sq.flags, .Unordered) & linux.IORING_SQ_NEED_WAKEUP) != 0) {

return self.sq.sqe_tail -% @atomicLoad(u32, self.sq.head, .Acquire);

return @atomicLoad(u32, self.cq.tail, .Acquire) -% self.cq.head.*;

return (@atomicLoad(u32, self.sq.flags, .Unordered) & linux.IORING_SQ_CQ_OVERFLOW) != 0;

@atomicStore(u32, self.cq.head, self.cq.head.* +% count, .Release);

_ = @atomicRmw(i32, ctx, AtomicRmwOp.Add, 1, AtomicOrder.SeqCst);

if (builtin.output_mode == .Lib and builtin.link_mode == .Dynamic) {

const suffix = switch (options.link_mode orelse .Static) {

.Static => ".lib",

.Dynamic => ".dll",

switch (options.link_mode orelse .Static) {

.Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{

.Dynamic => {

switch (options.link_mode orelse .Static) {

.Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{

.Dynamic => {

switch (options.link_mode orelse .Static) {

.Static => return std.fmt.allocPrint(allocator, "{s}{s}.a", .{

.Dynamic => return std.fmt.allocPrint(allocator, "{s}.wasm", .{root_name}),

.Auto,

if (layout != .Packed) {

.Auto => {},

.Extern => return astgen.failNode(node, "extern tuples are not supported", .{}),

.Packed => return astgen.failNode(node, "packed tuples are not supported", .{}),

.Packed => return astgen.failTok(member.comptime_token.?, "packed struct fields cannot be marked comptime", .{}),

.Extern => return astgen.failTok(member.comptime_token.?, "extern struct fields cannot be marked comptime", .{}),

.Auto => any_comptime_fields = true,

if (layout == .Packed) {

if (layout != .Auto and (auto_enum_tok != null or arg_node != 0)) {

const layout_str = if (layout == .Extern) "extern" else "packed";

return astgen.failNode(arg_node, "{s} union does not support enum tag type", .{layout_str});

return astgen.failTok(auto_enum_tok.?, "{s} union does not support enum tag type", .{layout_str});

const layout = if (container_decl.layout_token) |t| switch (token_tags[t]) {

.keyword_packed => std.builtin.Type.ContainerLayout.Packed,

.keyword_extern => std.builtin.Type.ContainerLayout.Extern,

} else std.builtin.Type.ContainerLayout.Auto;

const layout = if (container_decl.layout_token) |t| switch (token_tags[t]) {

.keyword_packed => std.builtin.Type.ContainerLayout.Packed,

.keyword_extern => std.builtin.Type.ContainerLayout.Extern,

} else std.builtin.Type.ContainerLayout.Auto;

@setFloatMode(.Strict);

.Extern => {

.Packed => {

.Auto => @compileError("auto layout struct"),

.Lib => options.config.link_mode == .Dynamic,

.Static => .{ .musl_crt_file = .libc_a },

.Dynamic => .{ .musl_crt_file = .libc_so },

.Lib => comp.config.link_mode == .Dynamic,

.Lib => comp.config.link_mode == .Dynamic,

.link_mode = .Static,

.Lib => (options.link_mode orelse .Static) == .Dynamic,

if (options.link_mode == .Dynamic) return error.TargetCannotDynamicLink;

break :b .Static;

if (options.link_mode == .Static) return error.LibCRequiresDynamicLinking;

break :b .Dynamic;

if (options.link_mode == .Static) return error.SharedLibrariesRequireDynamicLinking;

break :b .Dynamic;

break :b .Dynamic;

break :b .Static;

if (link_mode == .Dynamic) {

.Lib => if (link_mode == .Dynamic) {

.Lib => link_mode == .Dynamic,

.Packed => false,

.Auto, .Extern => s.flagsPtr(ip).known_non_opv,

assert(self.layout != .Packed);

assert(self.layout == .Packed);

if (s.layout == .Packed) return false;

if (s.layout == .Packed) return false;

if (s.layout == .Packed) return;

if (s.layout == .Packed) return false;

if (s.layout == .Packed) return;

if (s.layout == .Packed) return false;

if (s.layout == .Packed) return;

.Packed => {

.Auto, .Extern => {

.Packed => s.packedFlagsPtr(ip).field_inits_wip = false,

.Auto, .Extern => s.flagsPtr(ip).field_inits_wip = false,

if (s.layout == .Packed) return true;

assert(self.layout != .Packed);

assert(s.layout == .Packed);

assert(s.layout != .Packed);

.Packed => s.packedFlagsPtr(ip).inits_resolved,

.Auto, .Extern => s.flagsPtr(ip).inits_resolved,

.Packed => s.packedFlagsPtr(ip).inits_resolved = true,

.Auto, .Extern => s.flagsPtr(ip).inits_resolved = true,

.Packed => s.backingIntType(ip).* != .none,

.Auto, .Extern => s.flagsPtr(ip).layout_resolved,

return s.layout != .Packed and s.flagsPtr(ip).is_tuple;

return s.layout == .Auto;

assert(s.layout != .Packed);

.layout = .Auto,

.layout = if (extra.data.flags.is_extern) .Extern else .Auto,

.layout = .Packed,

 

.Auto => false,

.Extern => true,

.Packed => {

if (ini.layout == .Auto) {

linkage: std.builtin.GlobalLinkage = .Strong,

assert(small.layout == .Auto);

.layout = .Auto,

if (s.layout != .Packed) return null;

assert(layout != .Packed);

.Packed => unreachable,

.Auto => {

.Extern => return structFieldAlignmentExtern(mod, field_ty),

assert(struct_type.layout == .Packed);

if (options.global.link_mode == .Dynamic) {

float_mode: std.builtin.FloatMode = .Strict,

.tag = if (block.float_mode == .Optimized) .cmp_vector_optimized else .cmp_vector,

.cmp_eq => try sema.zirCmpEq(block, inst, .eq, Air.Inst.Tag.fromCmpOp(.eq, block.float_mode == .Optimized)),

.cmp_neq => try sema.zirCmpEq(block, inst, .neq, Air.Inst.Tag.fromCmpOp(.neq, block.float_mode == .Optimized)),

else if (small.layout != .Auto)

if (options.linkage == .Internal)

if (options.linkage == .Internal)

if (@intFromEnum(order) < @intFromEnum(std.builtin.AtomicOrder.Acquire)) {

return sema.fail(block, order_src, "atomic ordering must be Acquire or stricter", .{});

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

.Struct, .Union => if (dest_ty.containerLayout(mod) == .Auto) {

.Struct, .Union => if (operand_ty.containerLayout(mod) == .Auto) {

const cmp_ok = try case_block.addBinOp(if (case_block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, item);

if (case_block.float_mode == .Optimized) .cmp_gte_optimized else .cmp_gte,

if (case_block.float_mode == .Optimized) .cmp_lte_optimized else .cmp_lte,

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

return block.addUnOp(if (block.float_mode == .Optimized) .neg_optimized else .neg, rhs);

.Optimized => Air.Inst.Tag.div_float_optimized,

.Strict => Air.Inst.Tag.div_float,

.Strict => .reduce,

.Optimized => .reduce_optimized,

.Strict => .cmp_eq,

.Optimized => .cmp_eq_optimized,

if (!is_int and block.float_mode == .Strict) return;

.Strict => normal,

.Optimized => optimized,

const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .add_optimized else .add;

const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .sub_optimized else .sub;

const air_tag: Air.Inst.Tag = if (block.float_mode == .Optimized) .mul_optimized else .mul;

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

const tag = Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized);

.Auto, .Extern => try sema.unionFieldAlignment(union_obj, @intCast(i)),

.Packed => .none,

.Packed => .none,

const is_packed = resolved_ty.containerLayout(mod) == .Packed;

if (layout != .Packed and !backing_integer_val.isNull(mod)) {

else if (layout != .Auto)

if (layout == .Extern and !try sema.validateExternType(field_ty, .union_field)) {

} else if (layout == .Packed and !try sema.validatePackedType(field_ty)) {

.Extern => return sema.fail(block, src, "extern tuples are not supported", .{}),

.Packed => return sema.fail(block, src, "packed tuples are not supported", .{}),

.Auto => {},

if (layout != .Packed) {

if (layout == .Packed) return sema.fail(block, src, "alignment in a packed struct field must be set to 0", .{});

.Extern => return sema.fail(block, src, "extern struct fields cannot be marked comptime", .{}),

.Packed => return sema.fail(block, src, "packed struct fields cannot be marked comptime", .{}),

.Auto => struct_type.setFieldComptime(ip, field_idx),

if (layout == .Extern and !try sema.validateExternType(field_ty, .struct_field)) {

} else if (layout == .Packed and !try sema.validatePackedType(field_ty)) {

if (layout == .Packed) {

const ok = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, Air.internedToRef((try mod.floatValue(operand_ty, 0.0)).toIntern()));

const ok = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, elem_ref, Air.internedToRef((try mod.floatValue(operand_scalar_ty, 0.0)).toIntern()));

const result = try block.addTyOp(if (block.float_mode == .Optimized) .int_from_float_optimized else .int_from_float, dest_ty, operand);

const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, Air.internedToRef((try mod.floatValue(operand_ty, 1.0)).toIntern()));

const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, Air.internedToRef((try mod.floatValue(operand_ty, -1.0)).toIntern()));

const result = try block.addTyOp(if (block.float_mode == .Optimized) .int_from_float_optimized else .int_from_float, dest_scalar_ty, old_elem);

const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, Air.internedToRef((try mod.floatValue(operand_scalar_ty, 1.0)).toIntern()));

const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, Air.internedToRef((try mod.floatValue(operand_scalar_ty, -1.0)).toIntern()));

.Packed => {

if (visibility != .default and linkage == .Internal) {

if (@intFromEnum(success_order) < @intFromEnum(std.builtin.AtomicOrder.Monotonic)) {

return sema.fail(block, success_order_src, "success atomic ordering must be Monotonic or stricter", .{});

if (@intFromEnum(failure_order) < @intFromEnum(std.builtin.AtomicOrder.Monotonic)) {

return sema.fail(block, failure_order_src, "failure atomic ordering must be Monotonic or stricter", .{});

if (failure_order == .Release or failure_order == .AcqRel) {

return sema.fail(block, failure_order_src, "failure atomic ordering must not be Release or AcqRel", .{});

.tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,

.Release, .AcqRel => {

"@atomicLoad atomic ordering must not be Release or AcqRel",

if (order == .Unordered) {

return sema.fail(block, order_src, "@atomicRmw atomic ordering must not be Unordered", .{});

.Acquire, .AcqRel => {

"@atomicStore atomic ordering must not be Acquire or AcqRel",

.Unordered => .atomic_store_unordered,

.Monotonic => .atomic_store_monotonic,

.Release => .atomic_store_release,

.SeqCst => .atomic_store_seq_cst,

if (parent_ty.containerLayout(mod) == .Packed) {

linkage: std.builtin.GlobalLinkage = .Strong,

if (linkage != .Weak and linkage != .Strong) {

if (options.linkage == .Weak and !ty.ptrAllowsZero(mod)) {

.is_weak_linkage = options.linkage == .Weak,

.Extern => return true,

.Packed => {

.Auto => return !(try sema.typeHasRuntimeBits(ty)),

.Struct, .Union => return ty.containerLayout(mod) == .Packed,

if (struct_type.layout == .Packed) {

} else if (struct_type.layout == .Extern) {

.alignment = if (union_obj.getLayout(ip) == .Auto) blk: {

.Auto => if (!initializing) {

.Packed, .Extern => {},

if (!initializing and union_obj.getLayout(ip) == .Auto and block.wantSafety() and

.Auto => {

.Packed, .Extern => |layout| {

if (union_obj.getLayout(ip) == .Auto and block.wantSafety() and

if (layout == .Auto or (payload.tag != null and hypothetical_tag.eql(payload.tag.?, tag_type, mod))) {

.write_packed = layout == .Packed,

if (struct_obj != null and struct_obj.?.layout == .Packed) {

.Extern => offset: {

.Packed => offset: {

.Auto => unreachable,

return block.addBinOp(Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized), casted_lhs, casted_rhs);

return block.addBinOp(Air.Inst.Tag.fromCmpOp(op, block.float_mode == .Optimized), casted_lhs, casted_rhs);

assert(struct_type.layout != .Packed);

if (struct_type.layout == .Packed) {

.Packed => {

.Auto, .Extern => {

.Extern => if (!try sema.validateExternType(field_ty, .struct_field)) {

.Packed => if (!try sema.validatePackedType(field_ty)) {

if (layout == .Extern and

} else if (layout == .Packed and !try sema.validatePackedType(field_ty)) {

.Packed => return .none,

.Auto => if (mod.getTarget().ofmt != .c) return sema.typeAbiAlignment(field_ty),

.Extern => {},

.Auto => return error.IllDefinedMemoryLayout,

.Extern => for (0..struct_type.field_types.len) |i| {

.Packed => {

.Auto => return error.IllDefinedMemoryLayout, // Sema is supposed to have emitted a compile error already

.Extern => {

.Packed => {

assert(struct_type.layout == .Packed);

.Auto, .Extern => unreachable, // Handled in non-packed writeToMemory

.Packed => {

.Auto => unreachable, // Sema is supposed to have emitted a compile error already

.Extern => {

.Packed => {

.Auto => return error.IllDefinedMemoryLayout,

.Extern => {

.Packed => {

.Auto, .Extern => unreachable, // Handled by non-packed readFromMemory

.Packed => {

.layout = .Extern,

.atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),

.atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),

.atomic_store_release => try self.airAtomicStore(inst, .Release),

.atomic_store_seq_cst => try self.airAtomicStore(inst, .SeqCst),

if (ty.containerLayout(mod) == .Packed) return .byval;

if (ty.containerLayout(mod) == .Packed) return .byval;

.atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),

.atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),

.atomic_store_release => try self.airAtomicStore(inst, .Release),

.atomic_store_seq_cst => try self.airAtomicStore(inst, .SeqCst),

if (ty.containerLayout(mod) == .Packed) {

if (union_obj.getLayout(ip) == .Packed) {

.atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),

.atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),

.atomic_store_release => try self.airAtomicStore(inst, .Release),

.atomic_store_seq_cst => try self.airAtomicStore(inst, .SeqCst),

if (ty.containerLayout(mod) == .Packed) {

if (ty.containerLayout(mod) == .Packed) {

.Packed => {

if (union_obj.getLayout(ip) == .Packed) {

.Packed => 0,

assert(struct_type.layout == .Packed);

.Packed => switch (struct_ty.zigTypeTag(mod)) {

.Packed => switch (struct_ty.zigTypeTag(mod)) {

.Packed => {

if (struct_type.layout == .Packed) {

if (union_obj.getLayout(ip) == .Packed) {

if (union_obj.getLayout(ip) != .Packed) {

.atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),

.atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),

.atomic_store_release => try self.airAtomicStore(inst, .Release),

.atomic_store_seq_cst => try self.airAtomicStore(inst, .SeqCst),

.Auto, .Extern => @intCast(container_ty.structFieldOffset(index, mod) * 8),

.Packed => if (mod.typeToStruct(container_ty)) |struct_type|

.Unordered, .Monotonic => unreachable,

.Acquire, .Release, .AcqRel => {},

.SeqCst => try self.asmOpOnly(.{ ._, .mfence }),

.Unordered, .Monotonic, .Release, .AcqRel => .mov,

.Acquire => unreachable,

.SeqCst => .xchg,

if (result_ty.containerLayout(mod) == .Packed) {

.Lib => emit.lower.link_mode == .Static,

.Lib => emit.lower.link_mode == .Static,

.Lib => lower.link_mode == .Static,

.Struct, .Union => if (ty.containerLayout(mod) == .Packed) {

if (struct_type.layout == .Packed) {

if (union_obj.getLayout(ip) == .Packed) {

.Packed => {

.Auto, .Extern => {

.Auto, .Extern => @intCast(Type.fromInterned(base_ty).structFieldOffset(

.Packed => if (mod.typeToStruct(Type.fromInterned(base_ty))) |struct_obj|

.Auto, .Extern => {

.Packed => return writer.print("{x}", .{try dg.fmtIntLiteral(ty, Value.undef, .Other)}),

.Auto, .Extern => {

.Packed => {

.Packed => {

.Extern => {

if (union_obj.getLayout(ip) == .Packed) {

exports.items[0].opts.linkage == .Weak

if (@"export".opts.linkage == .Weak) try fwd.writeAll("zig_weak_linkage_fn ");

if (@"export".opts.linkage == .Weak) try fwd.writeAll("zig_weak_linkage ");

if (exports.items[0].opts.linkage == .Weak) try fwd_decl_writer.writeAll("zig_weak_linkage_fn ");

.atomic_store_unordered => try airAtomicStore(f, inst, toMemoryOrder(.Unordered)),

.atomic_store_monotonic => try airAtomicStore(f, inst, toMemoryOrder(.Monotonic)),

.atomic_store_release => try airAtomicStore(f, inst, toMemoryOrder(.Release)),

.atomic_store_seq_cst => try airAtomicStore(f, inst, toMemoryOrder(.SeqCst)),

.Auto, .Extern => {

.Packed => .begin,

.Auto, .Extern => if (struct_ty.isSimpleTuple(mod))

.Packed => {

if (union_obj.flagsPtr(ip).layout == .Packed) {

.Auto, .Extern => for (resolved_elements, 0..) |element, field_index| {

.Packed => {

if (union_obj.getLayout(ip) == .Packed) {

.Unordered, .Monotonic => "zig_memory_order_relaxed",

.Acquire => "zig_memory_order_acquire",

.Release => "zig_memory_order_release",

.AcqRel => "zig_memory_order_acq_rel",

.SeqCst => "zig_memory_order_seq_cst",

.Struct, .Union => |zig_ty_tag| if (ty.containerLayout(mod) == .Packed) {

else if (self.module.comp.config.link_mode == .Dynamic)

.Internal => unreachable,

.Strong => .external,

.Weak => .weak_odr,

.LinkOnce => .linkonce_odr,

if (struct_type.layout == .Packed) {

if (union_obj.flagsPtr(ip).layout == .Packed) {

if (struct_type.layout == .Packed) {

if (container_layout == .Packed) {

if (container_layout == .Packed) {

if (parent_ty.containerLayout(mod) == .Packed) {

.Packed => {

assert(struct_ty.containerLayout(mod) == .Packed);

assert(layout != .Packed);

assert(result_ty.containerLayout(mod) != .Packed);

if (union_obj.getLayout(ip) == .Packed) {

.Packed => {

if (layout.payload_size == 0 or struct_ty.containerLayout(mod) == .Packed) return struct_ptr;

.Unordered => .unordered,

.Monotonic => .monotonic,

.Acquire => .acquire,

.Release => .release,

.AcqRel => .acq_rel,

.SeqCst => .seq_cst,

if (struct_type.layout == .Packed) return false;

.Packed => return false,

.Struct => ty.containerLayout(mod) == .Packed,

.Union => ty.containerLayout(mod) == .Packed,

.layout = .Auto,

.Auto, .Extern => @compileError("Unsupported type: " ++ @typeName(T)),

.Packed => std.meta.Int(.unsigned, @bitSizeOf(T)),

if (struct_type.layout == .Packed) {

if (union_obj.getLayout(ip) == .Packed) {

if (struct_type.layout == .Packed) {

if (union_ty.getLayout(ip) == .Packed) {

.Packed => unreachable, // TODO

.Packed => unreachable, // TODO

.Packed => unreachable, // TODO

.Packed => unreachable, // TODO

if (info.layout == .Packed) {

.Struct => |info| if (info.layout == .Packed) 1 else extendedMaskSize(Operand, operand),

_ = panicking.fetchAdd(1, .SeqCst);

if (panicking.fetchSub(1, .SeqCst) != 1) {

.link_mode = .Dynamic,

const link_mode = .Static;

const link_mode = .Static;

const link_mode = .Static;

const link_mode = .Static;

.Static => return,

.Dynamic => {},

if (use_lld and output_mode == .Lib and link_mode == .Static) {

.Dynamic => executable_mode,

.Static => fs.File.default_mode,

return self.comp.config.link_mode == .Static;

if (exp.opts.linkage == .LinkOnce) {

"Unimplemented: GlobalLinkage.LinkOnce",

.Strong => {

.Internal => @panic("TODO Internal"),

.Weak => @panic("TODO WeakExternal"),

if (self.base.comp.config.output_mode == .Lib and self.base.comp.config.link_mode == .Dynamic) {

const is_dyn_lib = comp.config.link_mode == .Dynamic and is_lib;

.Dynamic => "",

.Static => "lib",

.Static => try argv.append(try allocPrint(arena, "libcmt{s}.lib", .{d_str})),

.Dynamic => try argv.append(try allocPrint(arena, "msvcrt{s}.lib", .{d_str})),

if (struct_type.layout == .Packed) {

const is_dyn_lib = output_mode == .Lib and link_mode == .Dynamic;

const is_obj_or_ar = is_obj or (output_mode == .Lib and link_mode == .Static);

if (try self.accessLibPath(arena, &test_path, &checked_paths, lc.crt_dir.?, lib_name, .Dynamic))

if (try self.accessLibPath(arena, &test_path, &checked_paths, lc.crt_dir.?, lib_name, .Static))

.Static => "libc.a",

.Dynamic => "libc.so",

const needs_grouping = link_mode == .Static;

.Static => "libc.a",

.Dynamic => "libc.so",

if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, lib_name, .Dynamic))

if (try self.accessLibPath(arena, &test_path, &checked_paths, lib_dir, lib_name, .Static))

.Static => target.staticLibSuffix(),

.Dynamic => target.dynamicLibSuffix(),

const is_dyn_lib = link_mode == .Dynamic and is_lib;

link_mode == .Dynamic and is_exe_or_dyn_lib;

if (link_mode == .Static) {

const needs_grouping = link_mode == .Static;

.Static => "libc.a",

.Dynamic => "libc.so",

.Static => @as(elf.ET, .REL),

.Dynamic => .DYN,

if (link_mode != .Static or comp.config.pie) break :blk;

.Dynamic => .dynamic_lib,

.Static => return CsuObjects{},

.Dynamic => if (comp.config.pie) .dynamic_pie else .dynamic_exe,

.Static => if (comp.config.pie) .static_pie else .static_exe,

.Internal => elf.STB_LOCAL,

.Strong => elf.STB_GLOBAL,

.Weak => elf.STB_WEAK,

.LinkOnce => {

if (exp.opts.linkage == .LinkOnce) {

"Unimplemented: GlobalLinkage.LinkOnce",

.Internal => {

.Strong => {},

.Weak => {

assert(comp.config.output_mode == .Lib and comp.config.link_mode == .Dynamic);

(output_mode == .Lib and link_mode == .Dynamic);

if (comp.config.output_mode == .Lib and comp.config.link_mode == .Dynamic) {

(comp.config.output_mode == .Lib and comp.config.link_mode == .Dynamic);

.Internal => {

.Weak => {

.Strong => {}, // symbols are strong by default

.LinkOnce => {

.Dynamic => .Static,

.Static => .Dynamic,

var lib_preferred_mode: std.builtin.LinkMode = .Dynamic;

lib_preferred_mode = .Dynamic;

lib_preferred_mode = .Static;

lib_preferred_mode = .Dynamic;

lib_preferred_mode = .Static;

lib_preferred_mode = .Dynamic;

lib_preferred_mode = .Static;

create_module.opts.link_mode = .Dynamic;

lib_preferred_mode = .Dynamic;

create_module.opts.link_mode = .Static;

lib_preferred_mode = .Static;

create_module.opts.link_mode = .Dynamic;

lib_preferred_mode = .Dynamic;

lib_preferred_mode = .Static;

lib_preferred_mode = .Dynamic;

lib_preferred_mode = .Dynamic;

.Lib => create_module.resolved_options.link_mode == .Dynamic,

.Static => try create_module.link_objects.append(arena, .{ .path = path }),

.Dynamic => try create_module.resolved_system_libs.append(arena, .{

.Static => try create_module.link_objects.append(arena, .{ .path = path }),

.Dynamic => try create_module.resolved_system_libs.append(arena, .{

.Static => try create_module.link_objects.append(arena, .{ .path = path }),

.Dynamic => try create_module.resolved_system_libs.append(arena, .{

.Static => try create_module.link_objects.append(arena, .{ .path = path }),

.Dynamic => try create_module.resolved_system_libs.append(arena, .{

const eti = @atomicLoad(usize, &node.unprotected_estimated_total_items, .Monotonic);

const completed_items = @atomicLoad(usize, &node.unprotected_completed_items, .Monotonic);

maybe_node = @atomicLoad(?*std.Progress.Node, &node.recently_updated_child, .Acquire);

if (target.isDarwin() and link_mode == .Dynamic) tbd: {

.Static => target.staticLibSuffix(),

.Dynamic => target.dynamicLibSuffix(),

if (target.isDarwin() and link_mode == .Dynamic) so: {

if (target.isMinGW() and link_mode == .Static) mingw: {

.link_mode = .Dynamic,

.atomic_store_unordered => try w.writeAtomicStore(s, inst, .Unordered),

.atomic_store_monotonic => try w.writeAtomicStore(s, inst, .Monotonic),

.atomic_store_release => try w.writeAtomicStore(s, inst, .Release),

.atomic_store_seq_cst => try w.writeAtomicStore(s, inst, .SeqCst),

try stream.writeAll("Packed(");

return struct_type.layout != .Auto or struct_type.field_types.len == 0;

.none, .safety => union_type.flagsPtr(ip).layout != .Auto,

if (struct_type.layout == .Packed) {

.Packed => {

.Auto, .Extern => {

.Packed => return .{

.Auto, .Extern => {

const is_packed = struct_type.layout == .Packed;

const is_packed = ty.containerLayout(mod) == .Packed;

.Extern => try mod.arrayType(.{ .len = ty.abiSize(mod), .child = .u8_type }),

.Packed => try mod.intType(.unsigned, @intCast(ty.bitSize(mod))),

.Auto => unreachable,

.anon_struct_type => .Auto,

.Struct => ty.containerLayout(mod) == .Packed,

if (struct_type.layout == .Packed)

assert(struct_type.layout != .Packed);

assert(struct_type.layout != .Packed);

if (struct_type.layout == .Packed) return false;

if (struct_type.layout == .Packed) return false;

if (@cmpxchgWeak(i32, &x, 99, 5678, .SeqCst, .SeqCst)) |x1| {

while (@cmpxchgWeak(i32, &x, 1234, 5678, .SeqCst, .SeqCst)) |x1| {

try expect(@cmpxchgStrong(i32, &x, 5678, 42, .SeqCst, .SeqCst) == null);

@fence(.SeqCst);

const prev_value = @atomicRmw(u8, ptr, .Xchg, 42, .SeqCst);

try expect(@atomicLoad(i32, &x, .SeqCst) == 1234);

try expect(@atomicLoad(i32, &y, .SeqCst) == 12345);

const x = @atomicLoad(u8, ptr, .SeqCst);

if (@cmpxchgWeak(*i32, &x, &data2, &data3, .SeqCst, .SeqCst)) |x1| {

while (@cmpxchgWeak(*i32, &x, &data1, &data3, .SeqCst, .SeqCst)) |x1| {

try expect(@cmpxchgStrong(*i32, &x, &data3, &data2, .SeqCst, .SeqCst) == null);

_ = @cmpxchgStrong(i32, &x, 1234, 5678, .Monotonic, .Monotonic);

if (@cmpxchgWeak(u128, &x, 99, 5678, .SeqCst, .SeqCst)) |x1| {

while (@cmpxchgWeak(u128, &x, 1234, 5678, .SeqCst, .SeqCst)) |x1| {

try expect(@cmpxchgStrong(u128, &x, 5678, 42, .SeqCst, .SeqCst) == null);

_ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .Acquire, .Monotonic);

try expect(@atomicLoad(Value, &x, .SeqCst) != .b);

_ = @atomicRmw(Value, &x, .Xchg, .c, .SeqCst);

try expect(@atomicLoad(Value, &x, .SeqCst) == .c);

try expect(@atomicLoad(Value, &x, .SeqCst) != .a);

try expect(@atomicLoad(Value, &x, .SeqCst) != .b);

@atomicStore(u32, &x, 1, .SeqCst);

try expect(@atomicLoad(u32, &x, .SeqCst) == 1);

@atomicStore(u32, &x, 12345678, .SeqCst);

try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);

@atomicStore(u32, &x, 1, .SeqCst);

try expect(@atomicLoad(u32, &x, .SeqCst) == 1);

@atomicStore(u32, &x, 12345678, .SeqCst);

try expect(@atomicLoad(u32, &x, .SeqCst) == 12345678);

_ = @atomicRmw(f32, &x, .Xchg, 1, .SeqCst);

_ = @atomicRmw(f32, &x, .Add, 5, .SeqCst);

_ = @atomicRmw(f32, &x, .Sub, 2, .SeqCst);

_ = @atomicRmw(f32, &x, .Max, 13, .SeqCst);

_ = @atomicRmw(f32, &x, .Min, 42, .SeqCst);

var res = @atomicRmw(int, &x, .Xchg, 3, .SeqCst);

res = @atomicRmw(int, &x, .Add, 3, .SeqCst);

res = @atomicRmw(int, &x, .Sub, 1, .SeqCst);

res = @atomicRmw(int, &x, .And, 4, .SeqCst);

res = @atomicRmw(int, &x, .Nand, 4, .SeqCst);

res = @atomicRmw(int, &x, .Or, 6, .SeqCst);

res = @atomicRmw(int, &x, .Xor, 2, .SeqCst);

res = @atomicRmw(int, &x, .Max, 1, .SeqCst);

res = @atomicRmw(int, &x, .Min, 1, .SeqCst);

var res = @atomicRmw(int, &x, .Xchg, replacement, .SeqCst);

res = @atomicRmw(int, &x, .Add, operator, .SeqCst);

res = @atomicRmw(int, &x, .Sub, operator, .SeqCst);

res = @atomicRmw(int, &x, .And, operator, .SeqCst);

res = @atomicRmw(int, &x, .Nand, operator, .SeqCst);

res = @atomicRmw(int, &x, .Or, operator, .SeqCst);

res = @atomicRmw(int, &x, .Xor, operator, .SeqCst);

res = @atomicRmw(int, &x, .Max, operator, .SeqCst);

res = @atomicRmw(int, &x, .Min, operator, .SeqCst);

@atomicStore(T, &x, a, .SeqCst);

try expect(@atomicLoad(T, &x, .SeqCst) == a);

try expect(@atomicRmw(T, &x, .Xchg, b, .SeqCst) == a);

try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst) == null);

try expect(@cmpxchgStrong(T, &x, b, a, .SeqCst, .SeqCst).? == a);

return @atomicStore(usize, &self.value, value, .Unordered);

else => @atomicStore(usize, &self.value, value, .Unordered),

try testing.expectEqual({}, @atomicStore(u8, &val, 0, .Unordered));

try testing.expectEqual({}, @fence(.Acquire));

try testing.expectEqual({}, @setFloatMode(.Optimized));

@export(foo, .{ .name = "exporting_with_internal_linkage_foo", .linkage = .Internal });

@export(Inner.x, .{ .name = "foo", .linkage = .Internal });

@setFloatMode(std.builtin.FloatMode.Strict);

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

try expect(info.layout == .Auto);

try testing.expectEqual(Type.ContainerLayout.Auto, infoA.layout);

try testing.expectEqual(Type.ContainerLayout.Extern, infoB.layout);

try testing.expectEqual(Type.ContainerLayout.Packed, infoC.layout);

try testing.expectEqual(Type.ContainerLayout.Auto, infoD.layout);

try testing.expectEqual(Type.ContainerLayout.Auto, infoE.layout);

try testing.expectEqual(Type.ContainerLayout.Auto, infoF.layout);

try testing.expectEqual(Type.ContainerLayout.Auto, infoG.layout);

.layout = .Extern,

.layout = .Packed,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

try expect(typeinfo_info.Union.layout == .Auto);

try expect(notag_union_info.Union.layout == .Auto);

try expect(extern_union_info.Union.layout == .Extern);

try expect(struct_info.Struct.layout == .Packed);

@atomicStore(u32, &x, 1, .Acquire);

// :3:31: error: @atomicStore atomic ordering must not be Acquire or AcqRel

while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}

while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}

// :4:58: error: success atomic ordering must be Monotonic or stricter

@fence(.Monotonic);

// :2:13: error: atomic ordering must be Acquire or stricter

_ = @atomicRmw(bool, &x, .Add, true, .SeqCst);

_ = @atomicRmw(E, &x, .Add, .b, .SeqCst);

_ = @atomicRmw(f32, &x, .And, 2, .SeqCst);

_ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);

_ = @Type(.{ .Struct = .{ .layout = .Packed, .fields = &.{

while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Extern,

.layout = .Packed,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

.layout = .Auto,

\\ @export(weakFoo, .{ .name = "weakFoo", .linkage = .Weak });

\\ @export(strongBar, .{ .name = "strongBarAlias", .linkage = .Strong });

\\ @export(foo, .{ .name = "bar", .linkage = .Strong });

@export(internal_integer, .{ .name = "internal_integer", .linkage = .Internal });

@export(obj1_integer, .{ .name = "obj1_integer", .linkage = .Strong });

@export(internal_integer, .{ .name = "internal_integer", .linkage = .Internal });

@export(obj2_integer, .{ .name = "obj2_integer", .linkage = .Strong });

link_mode = .Dynamic;

.Static => {

.Dynamic => {