TheCloud/v
1
0
Fork 0
mirror of https://github.com/vlang/v.git synced 2025-08-04 02:07:28 -04:00
Code Issues Packages Projects Releases Wiki Activity

sync,os,thirdparty: fix cross compilation from macos to windows (#21484)

Browse Source
This commit is contained in:
Delyan Angelov 2024-05-10 22:04:52 +03:00 committed by GitHub
parent 1eead82915
commit 776e7ad0b1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 44 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/bootstrapping_ci.yml vendored
View File

@ -79,8 +79,8 @@ jobs:
-H "Accept: application/vnd.github+json" \ -H "Accept: application/vnd.github+json" \
-H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \ -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
-H "X-GitHub-Api-Version: 2022-11-28" \ -H "X-GitHub-Api-Version: 2022-11-28" \
"https://api.github.com/repos/vlang/v/actions/workflows/18477644/runs?branch=master&status=success&per_page=2" \ "https://api.github.com/repos/vlang/v/actions/workflows/18477644/runs?branch=master&status=success&event=push&per_page=5&page=2" \
| jq -r '.workflow_runs[1].head_sha') | jq -r '.workflow_runs[4].head_sha')
echo "recent_good_commit=$recent_good_commit" echo "recent_good_commit=$recent_good_commit"
# Build oldv at recent_good_commit. # Build oldv at recent_good_commit.
./v run cmd/tools/oldv.v -v $recent_good_commit ./v run cmd/tools/oldv.v -v $recent_good_commit

8
thirdparty/stdatomic/nix/atomic.h vendored
View File

@ -107,10 +107,10 @@ static inline void** atomic_load(void** x) {
static inline void atomic_store(void** x, void* y) { static inline void atomic_store(void** x, void* y) {
atomic_store_explicit((unsigned long long*)x, (uintptr_t)y, memory_order_seq_cst); atomic_store_explicit((unsigned long long*)x, (uintptr_t)y, memory_order_seq_cst);
} }
static inline int atomic_compare_exchange_weak(void** x, void** expected, void* y) { static inline int atomic_compare_exchange_weak(void** x, void** expected, intptr_t y) {
return (int)atomic_compare_exchange_weak_explicit((unsigned long long*)x, (unsigned long long*)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst); return (int)atomic_compare_exchange_weak_explicit((unsigned long long*)x, (unsigned long long*)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst);
} }
static inline int atomic_compare_exchange_strong(void** x, void** expected, void* y) { static inline int atomic_compare_exchange_strong(void** x, void** expected, intptr_t y) {
return (int)atomic_compare_exchange_strong_explicit((unsigned long long*)x, (unsigned long long*)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst); return (int)atomic_compare_exchange_strong_explicit((unsigned long long*)x, (unsigned long long*)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst);
} }
static inline uintptr_t atomic_exchange(void** x, void* y) { static inline uintptr_t atomic_exchange(void** x, void* y) {
@ -311,10 +311,10 @@ static inline void* atomic_load_ptr(void** x) {
static inline void atomic_store_ptr(void** x, void* y) { static inline void atomic_store_ptr(void** x, void* y) {
atomic_store_explicit((_Atomic(uintptr_t)*)x, (uintptr_t)y, memory_order_seq_cst); atomic_store_explicit((_Atomic(uintptr_t)*)x, (uintptr_t)y, memory_order_seq_cst);
} }
static inline int atomic_compare_exchange_weak_ptr(void** x, void** expected, void* y) { static inline int atomic_compare_exchange_weak_ptr(void** x, void** expected, intptr_t y) {
return (int)atomic_compare_exchange_weak_explicit((_Atomic(uintptr_t)*)x, (unsigned long *)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst); return (int)atomic_compare_exchange_weak_explicit((_Atomic(uintptr_t)*)x, (unsigned long *)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst);
} }
static inline int atomic_compare_exchange_strong_ptr(void** x, void** expected, void* y) { static inline int atomic_compare_exchange_strong_ptr(void** x, void** expected, intptr_t y) {
return (int)atomic_compare_exchange_strong_explicit((_Atomic(uintptr_t)*)x, (unsigned long *)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst); return (int)atomic_compare_exchange_strong_explicit((_Atomic(uintptr_t)*)x, (unsigned long *)expected, (uintptr_t)y, memory_order_seq_cst, memory_order_seq_cst);
} }
static inline void* atomic_exchange_ptr(void** x, void* y) { static inline void* atomic_exchange_ptr(void** x, void* y) {

4
thirdparty/stdatomic/win/atomic.h vendored
View File

@ -270,7 +270,7 @@ static inline int atomic_compare_exchange_strong_u32(unsigned* object, unsigned*
unsigned desired) unsigned desired)
{ {
unsigned old = *expected; unsigned old = *expected;
*expected = InterlockedCompareExchange(object, desired, old); *expected = InterlockedCompareExchange((void *)object, desired, old);
return *expected == old; return *expected == old;
} }
@ -317,7 +317,7 @@ static inline int atomic_compare_exchange_strong_u16(unsigned short* object, uns
} }
#define atomic_compare_exchange_weak_u16(object, expected, desired) \ #define atomic_compare_exchange_weak_u16(object, expected, desired) \
atomic_compare_exchange_strong_u16(object, expected, desired) atomic_compare_exchange_strong_u16((void*)object, expected, desired)
#define atomic_fetch_add_u16(object, operand) \ #define atomic_fetch_add_u16(object, operand) \
InterlockedExchangeAdd16(object, operand) InterlockedExchangeAdd16(object, operand)

6
vlib/os/filelock/lib_windows.c.v
View File

@ -6,7 +6,7 @@ fn C.CloseHandle(voidptr) bool
pub fn (mut l FileLock) unlink() { pub fn (mut l FileLock) unlink() {
if l.fd != -1 { if l.fd != -1 {
C.CloseHandle(l.fd) C.CloseHandle(voidptr(l.fd))
l.fd = -1 l.fd = -1
} }
t_wide := l.name.to_wide() t_wide := l.name.to_wide()
@ -21,7 +21,7 @@ pub fn (mut l FileLock) acquire() ! {
if fd == -1 { if fd == -1 {
return error_with_code('cannot create lock file ${l.name}', -1) return error_with_code('cannot create lock file ${l.name}', -1)
} }
l.fd = fd l.fd = int(fd)
} }
fn open(f string) voidptr { fn open(f string) voidptr {
@ -41,6 +41,6 @@ pub fn (mut l FileLock) try_acquire() bool {
if fd == -1 { if fd == -1 {
return false return false
} }
l.fd = fd l.fd = int(fd)
return true return true
} }

46
vlib/sync/channels.c.v
View File

@ -123,8 +123,8 @@ pub fn (mut ch Channel) close() {
return return
} }
mut nulladr := unsafe { nil } mut nulladr := unsafe { nil }
for !C.atomic_compare_exchange_weak_ptr(unsafe { &voidptr(&ch.adr_written) }, &nulladr, for !C.atomic_compare_exchange_weak_ptr(voidptr(&ch.adr_written), voidptr(&nulladr),
voidptr(-1)) { isize(-1)) {
nulladr = unsafe { nil } nulladr = unsafe { nil }
} }
ch.readsem_im.post() ch.readsem_im.post()
@ -184,14 +184,14 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
mut got_sem := false mut got_sem := false
mut wradr := C.atomic_load_ptr(unsafe { &voidptr(&ch.write_adr) }) mut wradr := C.atomic_load_ptr(unsafe { &voidptr(&ch.write_adr) })
for wradr != C.NULL { for wradr != C.NULL {
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.write_adr) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.write_adr), voidptr(&wradr),
&wradr, unsafe { nil }) isize(0))
{ {
// there is a reader waiting for us // there is a reader waiting for us
unsafe { C.memcpy(wradr, src, ch.objsize) } unsafe { C.memcpy(wradr, src, ch.objsize) }
mut nulladr := unsafe { nil } mut nulladr := unsafe { nil }
for !C.atomic_compare_exchange_weak_ptr(unsafe { &voidptr(&ch.adr_written) }, for !C.atomic_compare_exchange_weak_ptr(voidptr(&ch.adr_written), voidptr(&nulladr),
&nulladr, wradr) { isize(wradr)) {
nulladr = unsafe { nil } nulladr = unsafe { nil }
} }
ch.readsem_im.post() ch.readsem_im.post()
@ -225,8 +225,8 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
wradr = C.atomic_load_ptr(unsafe { &voidptr(&ch.write_adr) }) wradr = C.atomic_load_ptr(unsafe { &voidptr(&ch.write_adr) })
if wradr != C.NULL { if wradr != C.NULL {
mut src2 := src mut src2 := src
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.read_adr) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.read_adr), voidptr(&src2),
&src2, unsafe { nil }) isize(0))
{ {
ch.writesem.post() ch.writesem.post()
continue continue
@ -247,8 +247,8 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
} }
mut src2 := src mut src2 := src
for sp := u32(0); sp < spinloops_ || read_in_progress; sp++ { for sp := u32(0); sp < spinloops_ || read_in_progress; sp++ {
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.adr_read) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.adr_read), voidptr(&src2),
&src2, unsafe { nil }) isize(0))
{ {
have_swapped = true have_swapped = true
read_in_progress = true read_in_progress = true
@ -271,7 +271,7 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
} }
if C.atomic_load_u16(&ch.closed) != 0 { if C.atomic_load_u16(&ch.closed) != 0 {
if have_swapped if have_swapped
|| C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.adr_read) }, &src2, unsafe { nil }) { || C.atomic_compare_exchange_strong_ptr(voidptr(&ch.adr_read), voidptr(&src2), isize(0)) {
ch.writesem.post() ch.writesem.post()
return .success return .success
} else { } else {
@ -279,7 +279,7 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
} }
} }
if have_swapped if have_swapped
|| C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.adr_read) }, &src2, unsafe { nil }) { || C.atomic_compare_exchange_strong_ptr(voidptr(&ch.adr_read), voidptr(&src2), isize(0)) {
ch.writesem.post() ch.writesem.post()
break break
} else { } else {
@ -332,7 +332,7 @@ fn (mut ch Channel) try_push_priv(src voidptr, no_block bool) ChanState {
C.memcpy(wr_ptr, src, ch.objsize) C.memcpy(wr_ptr, src, ch.objsize)
} }
C.atomic_store_u16(unsafe { &u16(status_adr) }, u16(BufferElemStat.written)) C.atomic_store_u16(unsafe { &u16(status_adr) }, u16(BufferElemStat.written))
C.atomic_fetch_add_u32(&ch.read_avail, 1) C.atomic_fetch_add_u32(voidptr(&ch.read_avail), 1)
ch.readsem.post() ch.readsem.post()
mut null16 := u16(0) mut null16 := u16(0)
for !C.atomic_compare_exchange_weak_u16(&ch.read_sub_mtx, &null16, u16(1)) { for !C.atomic_compare_exchange_weak_u16(&ch.read_sub_mtx, &null16, u16(1)) {
@ -375,14 +375,14 @@ fn (mut ch Channel) try_pop_priv(dest voidptr, no_block bool) ChanState {
// unbuffered channel - first see if a `push()` has adversized // unbuffered channel - first see if a `push()` has adversized
mut rdadr := C.atomic_load_ptr(unsafe { &voidptr(&ch.read_adr) }) mut rdadr := C.atomic_load_ptr(unsafe { &voidptr(&ch.read_adr) })
for rdadr != C.NULL { for rdadr != C.NULL {
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.read_adr) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.read_adr), voidptr(&rdadr),
&rdadr, unsafe { nil }) isize(0))
{ {
// there is a writer waiting for us // there is a writer waiting for us
unsafe { C.memcpy(dest, rdadr, ch.objsize) } unsafe { C.memcpy(dest, rdadr, ch.objsize) }
mut nulladr := unsafe { nil } mut nulladr := unsafe { nil }
for !C.atomic_compare_exchange_weak_ptr(unsafe { &voidptr(&ch.adr_read) }, for !C.atomic_compare_exchange_weak_ptr(voidptr(&ch.adr_read), voidptr(&nulladr),
&nulladr, rdadr) { isize(rdadr)) {
nulladr = unsafe { nil } nulladr = unsafe { nil }
} }
ch.writesem_im.post() ch.writesem_im.post()
@ -453,7 +453,7 @@ fn (mut ch Channel) try_pop_priv(dest voidptr, no_block bool) ChanState {
C.memcpy(dest, rd_ptr, ch.objsize) C.memcpy(dest, rd_ptr, ch.objsize)
} }
C.atomic_store_u16(unsafe { &u16(status_adr) }, u16(BufferElemStat.unused)) C.atomic_store_u16(unsafe { &u16(status_adr) }, u16(BufferElemStat.unused))
C.atomic_fetch_add_u32(&ch.write_free, 1) C.atomic_fetch_add_u32(voidptr(&ch.write_free), 1)
ch.writesem.post() ch.writesem.post()
mut null16 := u16(0) mut null16 := u16(0)
for !C.atomic_compare_exchange_weak_u16(&ch.write_sub_mtx, &null16, u16(1)) { for !C.atomic_compare_exchange_weak_u16(&ch.write_sub_mtx, &null16, u16(1)) {
@ -472,8 +472,8 @@ fn (mut ch Channel) try_pop_priv(dest voidptr, no_block bool) ChanState {
mut rdadr := C.atomic_load_ptr(unsafe { &voidptr(&ch.read_adr) }) mut rdadr := C.atomic_load_ptr(unsafe { &voidptr(&ch.read_adr) })
if rdadr != C.NULL { if rdadr != C.NULL {
mut dest2 := dest mut dest2 := dest
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.write_adr) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.write_adr), voidptr(&dest2),
&dest2, unsafe { nil }) isize(0))
{ {
ch.readsem.post() ch.readsem.post()
continue continue
@ -494,8 +494,8 @@ fn (mut ch Channel) try_pop_priv(dest voidptr, no_block bool) ChanState {
} }
mut dest2 := dest mut dest2 := dest
for sp := u32(0); sp < spinloops_ || write_in_progress; sp++ { for sp := u32(0); sp < spinloops_ || write_in_progress; sp++ {
if C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.adr_written) }, if C.atomic_compare_exchange_strong_ptr(voidptr(&ch.adr_written), voidptr(&dest2),
&dest2, unsafe { nil }) isize(0))
{ {
have_swapped = true have_swapped = true
break break
@ -519,7 +519,7 @@ fn (mut ch Channel) try_pop_priv(dest voidptr, no_block bool) ChanState {
ch.readsem_im.wait() ch.readsem_im.wait()
} }
if have_swapped if have_swapped
|| C.atomic_compare_exchange_strong_ptr(unsafe { &voidptr(&ch.adr_written) }, &dest2, unsafe { nil }) { || C.atomic_compare_exchange_strong_ptr(voidptr(&ch.adr_written), voidptr(&dest2), isize(0)) {
ch.readsem.post() ch.readsem.post()
break break
} else { } else {

2
vlib/sync/pool/pool.c.v
View File

@ -111,7 +111,7 @@ fn process_in_thread(mut pool PoolProcessor, task_id int) {
cb := ThreadCB(pool.thread_cb) cb := ThreadCB(pool.thread_cb)
ilen := pool.items.len ilen := pool.items.len
for { for {
idx := int(C.atomic_fetch_add_u32(&pool.ntask, 1)) idx := int(C.atomic_fetch_add_u32(voidptr(&pool.ntask), 1))
if idx >= ilen { if idx >= ilen {
break break
} }

4
vlib/sync/stdatomic/1.declarations.c.v
View File

@ -94,8 +94,8 @@ $if linux {
// The following functions are actually generic in C // The following functions are actually generic in C
fn C.atomic_load_ptr(voidptr) voidptr fn C.atomic_load_ptr(voidptr) voidptr
fn C.atomic_store_ptr(voidptr, voidptr) fn C.atomic_store_ptr(voidptr, voidptr)
fn C.atomic_compare_exchange_weak_ptr(voidptr, voidptr, voidptr) bool fn C.atomic_compare_exchange_weak_ptr(voidptr, voidptr, isize) bool
fn C.atomic_compare_exchange_strong_ptr(voidptr, voidptr, voidptr) bool fn C.atomic_compare_exchange_strong_ptr(voidptr, voidptr, isize) bool
fn C.atomic_exchange_ptr(voidptr, voidptr) voidptr fn C.atomic_exchange_ptr(voidptr, voidptr) voidptr
fn C.atomic_fetch_add_ptr(voidptr, voidptr) voidptr fn C.atomic_fetch_add_ptr(voidptr, voidptr) voidptr
fn C.atomic_fetch_sub_ptr(voidptr, voidptr) voidptr fn C.atomic_fetch_sub_ptr(voidptr, voidptr) voidptr

2
vlib/sync/sync_windows.c.v
View File

@ -163,7 +163,7 @@ pub fn (mut sem Semaphore) post() {
} }
} }
C.AcquireSRWLockExclusive(&sem.mtx) C.AcquireSRWLockExclusive(&sem.mtx)
c = C.atomic_fetch_add_u32(&sem.count, 1) c = C.atomic_fetch_add_u32(voidptr(&sem.count), 1)
if c == 0 { if c == 0 {
C.WakeConditionVariable(&sem.cond) C.WakeConditionVariable(&sem.cond)
} }

4
vlib/sync/waitgroup.c.v
View File

@ -46,7 +46,7 @@ pub fn (mut wg WaitGroup) init() {
// and unblocks any wait() calls if task count becomes zero. // and unblocks any wait() calls if task count becomes zero.
// add panics if task count drops below zero. // add panics if task count drops below zero.
pub fn (mut wg WaitGroup) add(delta int) { pub fn (mut wg WaitGroup) add(delta int) {
old_nrjobs := int(C.atomic_fetch_add_u32(&wg.task_count, u32(delta))) old_nrjobs := int(C.atomic_fetch_add_u32(voidptr(&wg.task_count), u32(delta)))
new_nrjobs := old_nrjobs + delta new_nrjobs := old_nrjobs + delta
mut num_waiters := C.atomic_load_u32(&wg.wait_count) mut num_waiters := C.atomic_load_u32(&wg.wait_count)
if new_nrjobs < 0 { if new_nrjobs < 0 {
@ -79,6 +79,6 @@ pub fn (mut wg WaitGroup) wait() {
// no need to wait // no need to wait
return return
} }
C.atomic_fetch_add_u32(&wg.wait_count, 1) C.atomic_fetch_add_u32(voidptr(&wg.wait_count), 1)
wg.sem.wait() // blocks until task_count becomes 0 wg.sem.wait() // blocks until task_count becomes 0
} }

7
vlib/v/builder/msvc_windows.v
View File

@ -25,7 +25,7 @@ fn find_windows_kit_internal(key RegKey, versions []string) !string {
unsafe { unsafe {
for version in versions { for version in versions {
required_bytes := u32(0) // TODO: mut required_bytes := u32(0) // TODO: mut
result := C.RegQueryValueEx(key, version.to_wide(), 0, 0, 0, &required_bytes) result := C.RegQueryValueEx(key, version.to_wide(), 0, 0, 0, voidptr(&required_bytes))
length := required_bytes / 2 length := required_bytes / 2
if result != 0 { if result != 0 {
continue continue
@ -38,7 +38,8 @@ fn find_windows_kit_internal(key RegKey, versions []string) !string {
// //
else { else {
} }
result2 := C.RegQueryValueEx(key, version.to_wide(), 0, 0, value, &alloc_length) result2 := C.RegQueryValueEx(key, version.to_wide(), 0, 0, voidptr(value),
voidptr(&alloc_length))
if result2 != 0 { if result2 != 0 {
continue continue
} }
@ -85,7 +86,7 @@ fn find_windows_kit_root_by_reg(target_arch string) !WindowsKit {
root_key := RegKey(0) root_key := RegKey(0)
path := 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots' path := 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots'
rc := C.RegOpenKeyEx(builder.hkey_local_machine, path.to_wide(), 0, builder.key_query_value | builder.key_wow64_32key | builder.key_enumerate_sub_keys, rc := C.RegOpenKeyEx(builder.hkey_local_machine, path.to_wide(), 0, builder.key_query_value | builder.key_wow64_32key | builder.key_enumerate_sub_keys,
&root_key) voidptr(&root_key))
if rc != 0 { if rc != 0 {
return error('Unable to open root key') return error('Unable to open root key')