srctree

// then we return without doing the step, relying on another worker to

// queue this step up again when dependencies are met.

for (s.dependencies.items) |dep| {

.success, .skipped => continue,

.failure, .dependency_failure, .skipped_oom => {

return;

},

.precheck_done, .running => {

s.state = .running;

} else {

// Avoid running steps twice.

// Another worker got the job.

return;

}

 

handle_result: {

if (make_result) |_| {

} else |err| switch (err) {

error.MakeFailed => {

break :handle_result;

},

}

 

// Successful completion of a step, so we queue up its dependants as well.

 

: "memory"

);

} else flag: {

};

 

switch (flag) {

: "memory"

);

} else {

}

}

};

defer sl.release();

return src.*;

} else {

}

}

 

defer sl.release();

dst.* = value;

} else {

}

}

 

 

const mask = @as(WideAtomic, std.math.maxInt(T)) << inner_shift;

 

while (true) {

const old = @as(T, @truncate((wide_old & mask) >> inner_shift));

const new = update(val, old);

const wide_new = wide_old & ~mask | (@as(WideAtomic, new) << inner_shift);

wide_old = new_wide_old;

} else {

return old;

};

return wideUpdate(T, ptr, val, Updater.update);

} else {

}

}

 

expected.* = value;

return 0;

} else {

expected.* = old_value;

return 0;

}

return wideUpdate(T, ptr, val, Updater.update);

}

 

}

 

fn __atomic_fetch_add_1(ptr: *u8, val: u8, model: i32) callconv(.C) u8 {

 

/// This is the same as calling `start` and then `end` on the returned `Node`. Thread-safe.

pub fn completeOne(self: *Node) void {

if (self.parent) |parent| {

}

self.context.maybeRefresh();

}

 

{

self.context.update_mutex.lock();

defer self.context.update_mutex.unlock();

}

parent.completeOne();

} else {

/// Tell the parent node that this node is actively being worked on. Thread-safe.

pub fn activate(self: *Node) void {

if (self.parent) |parent| {

self.context.maybeRefresh();

}

}

defer progress.update_mutex.unlock();

self.name = name;

if (self.parent) |parent| {

if (parent.parent) |grand_parent| {

}

if (progress.timer) |*timer| progress.maybeRefreshWithHeldLock(timer);

}

defer progress.update_mutex.unlock();

self.unit = unit;

if (self.parent) |parent| {

if (parent.parent) |grand_parent| {

}

if (progress.timer) |*timer| progress.maybeRefreshWithHeldLock(timer);

}

 

/// Thread-safe. 0 means unknown.

pub fn setEstimatedTotalItems(self: *Node, count: usize) void {

}

 

/// Thread-safe.

pub fn setCompletedItems(self: *Node, completed_items: usize) void {

}

};

 

self.bufWrite(&end, "... ", .{});

}

need_ellipse = false;

const current_item = completed_items + 1;

if (node.name.len != 0 or eti > 0) {

if (node.name.len != 0) {

need_ellipse = false;

}

}

}

if (need_ellipse) {

self.bufWrite(&end, "... ", .{});

 

 

fn entryFn(raw_ptr: windows.PVOID) callconv(.C) windows.DWORD {

const self: *@This() = @ptrCast(@alignCast(raw_ptr));

.running => {},

.completed => unreachable,

.detached => self.thread.free(),

 

fn detach(self: Impl) void {

windows.CloseHandle(self.thread.thread_handle);

.running => {},

.completed => self.thread.free(),

.detached => unreachable,

fn join(self: Impl) void {

windows.WaitForSingleObjectEx(self.thread.thread_handle, windows.INFINITE, false) catch unreachable;

windows.CloseHandle(self.thread.thread_handle);

self.thread.free();

}

};

}

 

fn getHandle(self: Impl) ThreadHandle {

}

 

fn detach(self: Impl) void {

.running => {},

.completed => self.join(),

.detached => unreachable,

 

var spin: u8 = 10;

while (true) {

if (tid == 0) {

break;

}

if (tid < 0) {

return error.SystemResources;

}

 

return .{ .thread = &instance.thread };

}

}

__set_stack_pointer(arg.thread.memory.ptr + arg.stack_offset);

__wasm_init_tls(arg.thread.memory.ptr + arg.tls_offset);

 

// Finished bootstrapping, call user's procedure.

arg.call_back(arg.raw_ptr);

 

.running => {

// reset the Thread ID

asm volatile (

 

fn entryFn(raw_arg: usize) callconv(.C) u8 {

const self = @as(*@This(), @ptrFromInt(raw_arg));

.running => {},

.completed => unreachable,

.detached => self.thread.freeAndExit(),

}

 

fn detach(self: Impl) void {

.running => {},

.completed => self.join(),

.detached => unreachable,

 

var spin: u8 = 10;

while (true) {

if (tid == 0) {

break;

}

 

 

if (comptime builtin.mode == .Debug) {

// The internal state of the DebugMutex needs to be handled here as well.

}

const rc = os.windows.kernel32.SleepConditionVariableSRW(

&self.condition,

);

if (comptime builtin.mode == .Debug) {

// The internal state of the DebugMutex needs to be handled here as well.

}

 

// Return error.Timeout if we know the timeout elapsed correctly.

// - T1: s & signals == 0 -> FUTEX_WAIT(&epoch, e) (missed the state update + the epoch change)

//

// Acquire barrier to ensure the epoch load happens before the state load.

assert(state & waiter_mask != waiter_mask);

state += one_waiter;

 

// Acquire barrier ensures code before the wake() which added the signal happens before we decrement it and return.

while (state & signal_mask != 0) {

const new_state = state - one_waiter - one_signal;

}

 

// Remove the waiter we added and officially return timed out.

const new_state = state - one_waiter;

}

},

};

 

 

// Try to wake up by consuming a signal and decremented the waiter we added previously.

// Acquire barrier ensures code before the wake() which added the signal happens before we decrement it and return.

while (state & signal_mask != 0) {

const new_state = state - one_waiter - one_signal;

}

}

}

 

fn wake(self: *Impl, comptime notify: Notify) void {

while (true) {

const waiters = (state & waiter_mask) / one_waiter;

const signals = (state & signal_mask) / one_signal;

// Reserve the amount of waiters to wake by incrementing the signals count.

// Release barrier ensures code before the wake() happens before the signal it posted and consumed by the wait() threads.

const new_state = state + (one_signal * to_wake);

// Wake up the waiting threads we reserved above by changing the epoch value.

// NOTE: a waiting thread could miss a wake up if *exactly* ((1<<32)-1) wake()s happen between it observing the epoch and sleeping on it.

// This is very unlikely due to how many precise amount of Futex.wake() calls that would be between the waiting thread's potential preemption.

// - T1: s = LOAD(&state)

// - T2: UPDATE(&state, signal) + FUTEX_WAKE(&epoch)

// - T1: s & signals == 0 -> FUTEX_WAIT(&epoch, e) (missed both epoch change and state change)

Futex.wake(&self.epoch, to_wake);

return;

};

 

 

// Avoid calling into the OS for no-op timeouts.

if (timeout_ns == 0) {

return error.Timeout;

}

 

// - T1: bumps pending waiters (was reordered after the ptr == expect check)

// - T1: goes to sleep and misses both the ptr change and T2's wake up

//

assert(pending < std.math.maxInt(usize));

 

// If the wait gets cancelled, remove the pending count we previously added.

// This is done outside the mutex lock to keep the critical section short in case of contention.

var cancelled = false;

defer if (cancelled) {

assert(pending > 0);

};

 

// but the RMW operation unconditionally marks the cache-line as modified for others causing unnecessary fetching/contention.

//

// Instead we opt to do a full-fence + load instead which avoids taking ownership of the cache-line.

//

if (bucket.pending.load(.Monotonic) == 0) {

return;

}

current: u32 = 0,

 

fn hit(self: *@This()) void {

Futex.wake(&self.value, 1);

}

 

// Wait for the value to change from hit()

var new_value: u32 = undefined;

while (true) {

if (new_value != self.current) break;

Futex.wait(&self.value, self.current);

}

fn wait(self: *@This()) !void {

// Decrement the counter.

// Release ensures stuff before this barrier.wait() happens before the last one.

try testing.expect(count <= num_threads);

try testing.expect(count > 0);

 

// Acquire for the last counter ensures stuff before previous barrier.wait()s happened before it.

// Release on futex update ensures stuff before all barrier.wait()'s happens before they all return.

if (count - 1 == 0) {

Futex.wake(&self.futex, num_threads - 1);

return;

}

 

// Other threads wait until last counter wakes them up.

// Acquire on futex synchronizes with last barrier count to ensure stuff before all barrier.wait()'s happen before us.

Futex.wait(&self.futex, 0);

}

}

 

inline fn tryLock(self: *@This()) bool {

const locking = self.impl.tryLock();

if (locking) {

}

return locking;

}

 

inline fn lock(self: *@This()) void {

const current_id = Thread.getCurrentId();

@panic("Deadlock detected");

}

self.impl.lock();

}

 

inline fn unlock(self: *@This()) void {

self.impl.unlock();

}

};

// - `lock bts` is smaller instruction-wise which makes it better for inlining

if (comptime builtin.target.cpu.arch.isX86()) {

const locked_bit = @ctz(locked);

}

 

// Acquire barrier ensures grabbing the lock happens before the critical section

// and that the previous lock holder's critical section happens before we grab the lock.

}

 

fn lockSlow(self: *@This()) void {

 

// Avoid doing an atomic swap below if we already know the state is contended.

// An atomic swap unconditionally stores which marks the cache-line as modified unnecessarily.

Futex.wait(&self.state, contended);

}

 

//

// Acquire barrier ensures grabbing the lock happens before the critical section

// and that the previous lock holder's critical section happens before we grab the lock.

Futex.wait(&self.state, contended);

}

}

//

// Release barrier ensures the critical section happens before we let go of the lock

// and that our critical section happens before the next lock holder grabs the lock.

assert(state != unlocked);

 

if (state == contended) {

 

 

fn isSet(self: *const Impl) bool {

// Acquire barrier ensures memory accesses before set() happen before we return true.

}

 

fn wait(self: *Impl, timeout: ?u64) error{Timeout}!void {

// Try to set the state from `unset` to `waiting` to indicate

// to the set() thread that others are blocked on the ResetEvent.

// We avoid using any strict barriers until the end when we know the ResetEvent is set.

if (state == unset) {

}

 

// Wait until the ResetEvent is set since the state is waiting.

const wait_result = futex_deadline.wait(&self.state, waiting);

 

// Check if the ResetEvent was set before possibly reporting error.Timeout below.

if (state != waiting) {

break;

}

 

// Acquire barrier ensures memory accesses before set() happen before we return.

assert(state == is_set);

}

 

fn set(self: *Impl) void {

// Quick check if the ResetEvent is already set before doing the atomic swap below.

// set() could be getting called quite often and multiple threads calling swap() increases contention unnecessarily.

return;

}

 

// Mark the ResetEvent as set and unblock all waiters waiting on it if any.

// Release barrier ensures memory accesses before set() happen before the ResetEvent is observed to be "set".

Futex.wake(&self.state, std.math.maxInt(u32));

}

}

 

fn reset(self: *Impl) void {

}

};

 

counter: std.atomic.Value(usize) = std.atomic.Value(usize).init(num_threads),

 

fn wait(self: *@This()) void {

self.event.set();

}

}

 

 

pub fn tryLock(rwl: *DefaultRwLock) bool {

if (rwl.mutex.tryLock()) {

if (state & READER_MASK == 0) {

return true;

}

 

}

 

pub fn lock(rwl: *DefaultRwLock) void {

rwl.mutex.lock();

 

if (state & READER_MASK != 0)

rwl.semaphore.wait();

}

 

pub fn unlock(rwl: *DefaultRwLock) void {

rwl.mutex.unlock();

}

 

pub fn tryLockShared(rwl: *DefaultRwLock) bool {

if (state & (IS_WRITING | WRITER_MASK) == 0) {

_ = @cmpxchgStrong(

usize,

&rwl.state,

state,

state + READER,

) orelse return true;

}

 

if (rwl.mutex.tryLock()) {

rwl.mutex.unlock();

return true;

}

}

 

pub fn lockShared(rwl: *DefaultRwLock) void {

while (state & (IS_WRITING | WRITER_MASK) == 0) {

state = @cmpxchgWeak(

usize,

&rwl.state,

state,

state + READER,

) orelse return;

}

 

rwl.mutex.lock();

rwl.mutex.unlock();

}

 

pub fn unlockShared(rwl: *DefaultRwLock) void {

 

if ((state & READER_MASK == READER) and (state & IS_WRITING != 0))

rwl.semaphore.post();

self.rwl.lockShared();

defer self.rwl.unlockShared();

 

break;

 

try self.check();

 

}

}

 

 

event: std.Thread.ResetEvent = .{},

 

pub fn start(self: *WaitGroup) void {

assert((state / one_pending) < (std.math.maxInt(usize) / one_pending));

}

 

pub fn finish(self: *WaitGroup) void {

assert((state / one_pending) > 0);

 

if (state == (one_pending | is_waiting)) {

self.event.set();

}

}

 

pub fn wait(self: *WaitGroup) void {

assert(state & is_waiting == 0);

 

if ((state / one_pending) > 0) {

}

 

pub fn reset(self: *WaitGroup) void {

self.event.reset();

}

 

pub fn isDone(wg: *WaitGroup) bool {

assert(state & is_waiting == 0);

 

return (state / one_pending) == 0;

 

 

const addr: *anyopaque = self;

return switch (order) {

tsan.__tsan_acquire(addr);

tsan.__tsan_release(addr);

},

 

fn ref(rc: *RefCount) void {

// No ordering necessary; just updating a counter.

}

 

fn unref(rc: *RefCount) void {

// Release ensures code before unref() happens-before the

// count is decremented as dropFn could be called by then.

// previous unrefs()s happens-before we call dropFn

// below.

// Another alternative is to use .AcqRel on the

// fetchSub count decrement but it's extra barrier in

// possibly hot path.

(rc.dropFn)(rc);

}

}

 

test "Value.swap" {

var x = Value(usize).init(5);

 

const E = enum(usize) { a, b, c };

var y = Value(E).init(.c);

 

var z = Value(f32).init(5.0);

 

var a = Value(bool).init(false);

 

var b = Value(?*u8).init(null);

}

 

test "Value.store" {

var x = Value(usize).init(5);

}

 

test "Value.cmpxchgWeak" {

var x = Value(usize).init(0);

 

 

 

}

 

test "Value.cmpxchgStrong" {

var x = Value(usize).init(0);

}

 

test "Value.fetchAdd" {

var x = Value(usize).init(5);

}

 

test "Value.fetchSub" {

var x = Value(usize).init(5);

}

 

test "Value.fetchMin" {

var x = Value(usize).init(5);

}

 

test "Value.fetchMax" {

var x = Value(usize).init(5);

}

 

test "Value.fetchAnd" {

var x = Value(usize).init(0b11);

}

 

test "Value.fetchNand" {

var x = Value(usize).init(0b11);

}

 

test "Value.fetchOr" {

var x = Value(usize).init(0b11);

}

 

test "Value.fetchXor" {

var x = Value(usize).init(0b11);

}

 

test "Value.bitSet" {

const mask = @as(usize, 1) << bit;

 

// setting the bit should change the bit

 

// setting it again shouldn't change the bit

 

// all the previous bits should have not changed (still be set)

for (0..bit_index) |prev_bit_index| {

const prev_bit = @as(std.math.Log2Int(usize), @intCast(prev_bit_index));

const prev_mask = @as(usize, 1) << prev_bit;

}

}

}

x.raw |= mask;

 

// unsetting the bit should change the bit

 

// unsetting it again shouldn't change the bit

 

// all the previous bits should have not changed (still be reset)

for (0..bit_index) |prev_bit_index| {

const prev_bit = @as(std.math.Log2Int(usize), @intCast(prev_bit_index));

const prev_mask = @as(usize, 1) << prev_bit;

}

}

}

const mask = @as(usize, 1) << bit;

 

// toggling the bit should change the bit

 

// toggling it again *should* change the bit

 

// all the previous bits should have not changed (still be toggled back)

for (0..bit_index) |prev_bit_index| {

const prev_bit = @as(std.math.Log2Int(usize), @intCast(prev_bit_index));

const prev_mask = @as(usize, 1) << prev_bit;

}

}

}

 

/// This data structure is used by the Zig language code generation and

/// therefore must be kept in sync with the compiler implementation.

pub const AtomicOrder = enum {

};

 

/// This data structure is used by the Zig language code generation and

 

const pipe_path = std.fmt.bufPrintZ(

&tmp_buf,

"\\\\.\\pipe\\zig-childprocess-{d}-{d}",

) catch unreachable;

const len = std.unicode.wtf8ToWtf16Le(&tmp_bufw, pipe_path) catch unreachable;

tmp_bufw[len] = 0;

 

0 => {

panic_stage = 1;

 

 

// Make sure to release the mutex when done

{

 

/// Must be called only after adding 1 to `panicking`. There are three callsites.

fn waitForOtherThreadToFinishPanicking() void {

// Another thread is panicking, wait for the last one to finish

// and call abort()

if (builtin.single_threaded) unreachable;

nosuspend switch (panic_stage) {

0 => {

panic_stage = 1;

 

{

panic_mutex.lock();

nosuspend switch (panic_stage) {

0 => {

panic_stage = 1;

 

{

panic_mutex.lock();

 

 

const ptr_align = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_ptr_align));

const amt = n + ptr_align - 1 + @sizeOf(usize);

const heap_handle = optional_heap_handle orelse blk: {

const options = if (builtin.single_threaded) os.windows.HEAP_NO_SERIALIZE else 0;

const hh = os.windows.kernel32.HeapCreate(options, amt, 0) orelse return null;

os.windows.HeapDestroy(hh);

break :blk other_hh.?; // can't be null because of the cmpxchg

};

const self: *FixedBufferAllocator = @ptrCast(@alignCast(ctx));

_ = ra;

const ptr_align = @as(usize, 1) << @as(Allocator.Log2Align, @intCast(log2_ptr_align));

while (true) {

const adjust_off = mem.alignPointerOffset(self.buffer.ptr + end_index, ptr_align) orelse return null;

const adjusted_index = end_index + adjust_off;

const new_end_index = adjusted_index + n;

if (new_end_index > self.buffer.len) return null;

return self.buffer[adjusted_index..new_end_index].ptr;

}

}

 

return @ptrCast(addr);

}

 

const slice = os.mmap(

hint,

aligned_len,

) catch return null;

assert(mem.isAligned(@intFromPtr(slice.ptr), mem.page_size));

const new_hint: [*]align(mem.page_size) u8 = @alignCast(slice.ptr + aligned_len);

return slice.ptr;

}

 

 

 

const host = uri.host orelse return error.UriMissingHost;

 

if (disable_tls) unreachable;

 

client.ca_bundle_mutex.lock();

 

if (client.next_https_rescan_certs) {

client.ca_bundle.rescan(client.allocator) catch return error.CertificateBundleLoadFailure;

}

}

 

 

/// first time.

/// The invocations are thread-safe.

pub fn call(self: *@This()) void {

return;

 

return self.callSlow();

// The first thread to acquire the mutex gets to run the initializer

if (!self.done) {

f();

}

}

};

 

fn fchmodat2(dirfd: fd_t, path: []const u8, mode: mode_t, flags: u32) FChmodAtError!void {

const path_c = try toPosixPath(path);

const use_fchmodat2 = (builtin.os.isAtLeast(.linux, .{ .major = 6, .minor = 6, .patch = 0 }) orelse false) and

while (use_fchmodat2) {

// Later on this should be changed to `system.fchmodat2`

// when the musl/glibc add a wrapper.

.ROFS => return error.ReadOnlyFileSystem,

 

.NOSYS => { // Use fallback.

break;

},

else => |err| return unexpectedErrno(err),

const global = struct {

var abort_entered: bool = false;

};

}

 

// Install default handler so that the tkill below will terminate.

if ((comptime builtin.os.isAtLeast(.freebsd, .{ .major = 13, .minor = 0, .patch = 0 }) orelse false) or

((comptime builtin.os.isAtLeast(.linux, .{ .major = 4, .minor = 5, .patch = 0 }) orelse false and

std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 })) and

{

var off_in_copy: i64 = @bitCast(off_in);

var off_out_copy: i64 = @bitCast(off_out);

.TXTBSY => return error.SwapFile,

.XDEV => break, // support for cross-filesystem copy added in Linux 5.3, use fallback

.NOSYS => { // syscall added in Linux 4.5, use fallback

break;

},

else => |err| return unexpectedErrno(err),

 

 

pub fn clock_gettime(clk_id: i32, tp: *timespec) usize {

if (@hasDecl(VDSO, "CGT_SYM")) {

if (ptr) |fn_ptr| {

const f = @as(vdso_clock_gettime_ty, @ptrCast(fn_ptr));

const rc = f(clk_id, tp);

const ptr = @as(?*const anyopaque, @ptrFromInt(vdso.lookup(VDSO.CGT_VER, VDSO.CGT_SYM)));

// Note that we may not have a VDSO at all, update the stub address anyway

// so that clock_gettime will fall back on the good old (and slow) syscall

// Call into the VDSO if available

if (ptr) |fn_ptr| {

const f = @as(vdso_clock_gettime_ty, @ptrCast(fn_ptr));

 

/// alternative. In Zig, we have first-class error handling... so let's use it.

/// Matches the implementation of io_uring_get_sqe() in liburing.

pub fn get_sqe(self: *IoUring) !*linux.io_uring_sqe {

// Remember that these head and tail offsets wrap around every four billion operations.

// We must therefore use wrapping addition and subtraction to avoid a runtime crash.

const next = self.sq.sqe_tail +% 1;

self.sq.sqe_head +%= 1;

}

// Ensure that the kernel can actually see the SQE updates when it sees the tail update.

}

return self.sq_ready();

}

pub fn sq_ring_needs_enter(self: *IoUring, flags: *u32) bool {

assert(flags.* == 0);

if ((self.flags & linux.IORING_SETUP_SQPOLL) == 0) return true;

flags.* |= linux.IORING_ENTER_SQ_WAKEUP;

return true;

}

pub fn sq_ready(self: *IoUring) u32 {

// Always use the shared ring state (i.e. head and not sqe_head) to avoid going out of sync,

// see https://github.com/axboe/liburing/issues/92.

}

 

/// Returns the number of CQEs in the completion queue, i.e. its length.

/// These are CQEs that the application is yet to consume.

/// Matches the implementation of io_uring_cq_ready in liburing.

pub fn cq_ready(self: *IoUring) u32 {

}

 

/// Copies as many CQEs as are ready, and that can fit into the destination `cqes` slice.

 

/// Matches the implementation of cq_ring_needs_flush() in liburing.

pub fn cq_ring_needs_flush(self: *IoUring) bool {

}

 

/// For advanced use cases only that implement custom completion queue methods.

pub fn cq_advance(self: *IoUring, count: u32) void {

if (count > 0) {

// Ensure the kernel only sees the new head value after the CQEs have been read.

}

}

 

 

}

 

fn start2(ctx: *i32) u8 {

return 0;

}

 

 

.needed_comptime_reason = "atomic order of @fence must be comptime-known",

});

 

}

 

_ = try block.addInst(.{

.needed_comptime_reason = "atomic order of cmpxchg failure must be comptime-known",

});

 

}

}

if (@intFromEnum(failure_order) > @intFromEnum(success_order)) {

return sema.fail(block, failure_order_src, "failure atomic ordering must be no stricter than success", .{});

}

}

 

const result_ty = try mod.optionalType(elem_ty.toIntern());

});

 

switch (order) {

return sema.fail(

block,

order_src,

.{},

);

},

.needed_comptime_reason = "atomic order of @atomicRmW must be comptime-known",

});

 

}

 

// special case zero bit types

});

 

const air_tag: Air.Inst.Tag = switch (order) {

return sema.fail(

block,

order_src,

.{},

);

},

};

 

return sema.storePtr2(block, src, ptr, ptr_src, operand, operand_src, air_tag);

 

.call_never_tail => try self.airCall(inst, .never_tail),

.call_never_inline => try self.airCall(inst, .never_inline),

 

 

.struct_field_ptr_index_0 => try self.airStructFieldPtrIndex(inst, 0),

.struct_field_ptr_index_1 => try self.airStructFieldPtrIndex(inst, 1),

 

.call_never_tail => try self.airCall(inst, .never_tail),

.call_never_inline => try self.airCall(inst, .never_inline),

 

 

.struct_field_ptr_index_0 => try self.airStructFieldPtrIndex(inst, 0),

.struct_field_ptr_index_1 => try self.airStructFieldPtrIndex(inst, 1),

 

.call_never_tail => try self.airCall(inst, .never_tail),

.call_never_inline => try self.airCall(inst, .never_inline),

 

 

.struct_field_ptr_index_0 => try self.airStructFieldPtrIndex(inst, 0),

.struct_field_ptr_index_1 => try self.airStructFieldPtrIndex(inst, 1),

 

.call_never_tail => try self.airCall(inst, .never_tail),

.call_never_inline => try self.airCall(inst, .never_inline),

 

 

.struct_field_ptr_index_0 => try self.airStructFieldPtrIndex(inst, 0),

.struct_field_ptr_index_1 => try self.airStructFieldPtrIndex(inst, 1),

fn airFence(self: *Self, inst: Air.Inst.Index) !void {

const order = self.air.instructions.items(.data)[@intFromEnum(inst)].fence;

switch (order) {

}

self.finishAirBookkeeping();

}

.Xor => .xor,

else => unreachable,

} else switch (order) {

};

 

const dst_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);

 

 

.int_from_ptr => try airIntFromPtr(f, inst),

 

 

.struct_field_ptr_index_0 => try airStructFieldPtrIndex(f, inst, 0),

.struct_field_ptr_index_1 => try airStructFieldPtrIndex(f, inst, 1),

fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 {

return switch (order) {

// Note: unordered is actually even less atomic than relaxed

};

}

 

 

 

const reloc_mode: llvm.RelocMode = if (pic)

.PIC

llvm.RelocMode.DynamicNoPIC

else

.Static;

 

fn toLlvmAtomicOrdering(atomic_order: std.builtin.AtomicOrder) Builder.AtomicOrdering {

return switch (atomic_order) {

};

}

 

 

fmt_str = fmt_str ++ ")\n";

 

var fmt_args: @Type(.{ .Struct = .{

.fields = &fields,

.decls = &.{},

.is_tuple = false,

 

.Enum => |info| info.tag_type,

.Bool => u1,

.Struct => |info| switch (info.layout) {

},

else => @compileError("Unsupported type: " ++ @typeName(T)),

})));

 

};

state.* = new_state;

 

 

state.recover_stage = .release_ref_count;

 

noinline fn releaseRefCount(state: *volatile PanicState) noreturn {

state.recover_stage = .abort;

 

// Another thread is panicking, wait for the last one to finish

// and call abort()

 

 

buf.appendSlice("... ") catch {};

}

need_ellipse = false;

const current_item = completed_items + 1;

if (node.name.len != 0 or eti > 0) {

if (node.name.len != 0) {

need_ellipse = false;

}

}

}

}

 

 

.fence => try w.writeFence(s, inst),

.atomic_load => try w.writeAtomicLoad(s, inst),

.prefetch => try w.writePrefetch(s, inst),

.atomic_rmw => try w.writeAtomicRmw(s, inst),

.field_parent_ptr => try w.writeFieldParentPtr(s, inst),

.wasm_memory_size => try w.writeWasmMemorySize(s, inst),

 

 

fn testCmpxchg() !void {

var x: i32 = 1234;

try expect(x1 == 1234);

} else {

@panic("cmpxchg should have failed");

}

 

try expect(x1 == 1234);

}

try expect(x == 5678);

 

try expect(x == 42);

}

 

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

var x: i32 = 1234;

x = 5678;

}

 

}

 

fn testAtomicRmw(ptr: *u8) !void {

try expect(prev_value == 200);

comptime {

var x: i32 = 1234;

const y: i32 = 12345;

}

}

 

fn testAtomicLoad(ptr: *u8) !void {

try expect(x == 42);

}

 

var data2: i32 = 5678;

var data3: i32 = 9101;

var x: *i32 = &data1;

try expect(x1 == &data1);

} else {

@panic("cmpxchg should have failed");

}

 

try expect(x1 == &data1);

}

try expect(x == &data3);

 

try expect(x == &data2);

}

 

 

var x: i32 = 1234;

 

 

try expect(5678 == x);

}

 

fn test_u128_cmpxchg() !void {

var x: u128 align(16) = 1234;

try expect(x1 == 1234);

} else {

@panic("cmpxchg should have failed");

}

 

try expect(x1 == 1234);

}

try expect(x == 5678);

 

try expect(x == 42);

}

 

return error.SkipZigTest;

}

 

try expect(a_global_variable == 42);

}

 

const Value = enum(u8) { a, b, c };

var x = Value.a;

 

 

}

 

test "atomic store" {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

var x: u32 = 0;

}

 

test "atomic store comptime" {

 

fn testAtomicStore() !void {

var x: u32 = 0;

}

 

test "atomicrmw with floats" {

fn testAtomicRmwFloat() !void {

var x: f32 = 0;

try expect(x == 0);

try expect(x == 1);

try expect(x == 6);

try expect(x == 4);

try expect(x == 13);

try expect(x == 13);

}

 

const int = std.meta.Int(signedness, N);

 

var x: int = 1;

try expect(x == 3 and res == 1);

 

var y: int = 3;

try expect(res == y);

y = y + 3;

try expect(x == y);

 

try expect(res == y);

y = y - 1;

try expect(x == y);

 

try expect(res == y);

y = y & 4;

try expect(x == y);

 

try expect(res == y);

y = ~(y & 4);

try expect(x == y);

 

try expect(res == y);

y = y | 6;

try expect(x == y);

 

try expect(res == y);

y = y ^ 2;

try expect(x == y);

 

try expect(res == y);

y = @max(y, 1);

try expect(x == y);

 

try expect(res == y);

y = @min(y, 1);

try expect(x == y);

const replacement: int = 0x00000000_00000005_00000000_00000003;

 

var x: int align(16) = initial;

try expect(x == replacement and res == initial);

 

var operator: int = 0x00000001_00000000_20000000_00000000;

var y: int = replacement;

try expect(res == y);

y = y + operator;

try expect(x == y);

 

operator = 0x00000000_10000000_00000000_20000000;

try expect(res == y);

y = y - operator;

try expect(x == y);

 

operator = 0x12345678_87654321_12345678_87654321;

try expect(res == y);

y = y & operator;

try expect(x == y);

 

operator = 0x00000000_10000000_00000000_20000000;

try expect(res == y);

y = ~(y & operator);

try expect(x == y);

 

operator = 0x12340000_56780000_67890000_98760000;

try expect(res == y);

y = y | operator;

try expect(x == y);

 

operator = 0x0a0b0c0d_0e0f0102_03040506_0708090a;

try expect(res == y);

y = y ^ operator;

try expect(x == y);

 

operator = 0x00000000_10000000_00000000_20000000;

try expect(res == y);

y = @max(y, operator);

try expect(x == y);

 

try expect(res == y);

y = @min(y, operator);

try expect(x == y);

 

fn testAtomicsWithType(comptime T: type, a: T, b: T) !void {

var x: T = b;

try expect(x == a);

if (@sizeOf(T) != 0)

}

 

test "return @atomicStore, using it as a void value" {

value: usize,

 

pub fn store(self: *A, value: usize) void {

}

 

pub fn store2(self: *A, value: usize) void {

return switch (value) {

};

}

};

 

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

var val: u8 = undefined;

try testing.expectEqual(void, @TypeOf(@breakpoint()));

try testing.expectEqual({}, @export(x, .{ .name = "x" }));

try testing.expectEqual({}, @memcpy(@as([*]u8, @ptrFromInt(1))[0..0], @as([*]u8, @ptrFromInt(1))[0..0]));

try testing.expectEqual({}, @memset(@as([*]u8, @ptrFromInt(1))[0..0], undefined));

try testing.expectEqual(noreturn, @TypeOf(if (true) @panic("") else {}));

 

export fn entry() void {

var x: u32 = 0;

}

 

// error

// backend=stage2

// target=native

//

 

const AtomicOrder = @import("std").builtin.AtomicOrder;

export fn f() void {

var x: i32 = 1234;

}

 

// error

 

const AtomicOrder = @import("std").builtin.AtomicOrder;

export fn f() void {

var x: i32 = 1234;

}

 

// error

// backend=stage2

// target=native

//

 

export fn entry() void {

}

 

// error

// backend=stage2

// target=native

//

 

export fn entry() void {

var x = false;

}

 

// error

 

d,

};

var x: E = .a;

}

 

// error

 

export fn entry() void {

var x: f32 = 0;

}

 

// error

 

export fn entry() void {

var x: f32 = 0;

}

 

// error

 

const AtomicOrder = @import("std").builtin.AtomicOrder;

export fn entry() bool {

var x: i32 align(1) = 1234;

return x == 5678;

}