From 03cd6948f21715f3dd57ce1dee44ee5db9db8bb3 Mon Sep 17 00:00:00 2001 From: David Grove Date: Wed, 5 Jul 2017 18:06:31 -0400 Subject: [PATCH] fixes for compiler warnings work in progress on cleaning up code so it can be compiled with the same set of warning flags used on Darwin. This is an initial pass through the C files in src to resolve warnings. Most warnings are related to implicit size/sign conversions between integral types and missing explicit prototypes for non-static functions. --- src/BlocksRuntime/runtime.c | 10 +++++++- src/data.c | 2 ++ src/event/event_epoll.c | 48 +++++++++++++++++++------------------ src/event/workqueue.c | 16 ++++++------- src/internal.h | 20 +++++++++++----- src/io.c | 6 ++--- src/queue.c | 6 ++++- src/shims/hw_config.h | 6 ++--- src/shims/lock.c | 7 +++--- src/shims/lock.h | 6 ++--- src/swift/DispatchStubs.cc | 24 +++++++++++++++++++ src/voucher.c | 2 ++ 12 files changed, 101 insertions(+), 52 deletions(-) diff --git a/src/BlocksRuntime/runtime.c b/src/BlocksRuntime/runtime.c index 8ec64cdc2..8c98e8d1e 100644 --- a/src/BlocksRuntime/runtime.c +++ b/src/BlocksRuntime/runtime.c @@ -148,6 +148,8 @@ GC support stub routines static void *_Block_alloc_default(const unsigned long size, const bool initialCountIsOne, const bool isObject) { + (void)initialCountIsOne; + (void)isObject; return malloc(size); } @@ -156,6 +158,8 @@ static void _Block_assign_default(void *value, void **destptr) { } static void _Block_setHasRefcount_default(const void *ptr, const bool hasRefcount) { + (void)ptr; + (void)hasRefcount; } #if HAVE_OBJC @@ -163,9 +167,11 @@ static void _Block_do_nothing(const void *aBlock) { } #endif static void _Block_retain_object_default(const void *ptr) { + (void)ptr; } static void _Block_release_object_default(const void *ptr) { + (void)ptr; } static void _Block_assign_weak_default(const void *ptr, void *dest) { @@ -193,7 +199,9 @@ static void _Block_memmove_gc_broken(void *dest, void *src, unsigned long size) } #endif -static void _Block_destructInstance_default(const void *aBlock) {} +static void _Block_destructInstance_default(const void *aBlock) { + (void)aBlock; +} /************************************************************************** GC support callout functions - initially set to stub routines diff --git a/src/data.c b/src/data.c index 240309f45..3efab2f89 100644 --- a/src/data.c +++ b/src/data.c @@ -138,6 +138,8 @@ _dispatch_data_destroy_buffer(const void* buffer, size_t size, mach_vm_size_t vm_size = size; mach_vm_address_t vm_addr = (uintptr_t)buffer; mach_vm_deallocate(mach_task_self(), vm_addr, vm_size); +#else + (void)size; #endif } else { if (!queue) { diff --git a/src/event/event_epoll.c b/src/event/event_epoll.c index c86421b4e..add4dde65 100644 --- a/src/event/event_epoll.c +++ b/src/event/event_epoll.c @@ -48,7 +48,7 @@ typedef struct dispatch_muxnote_s { TAILQ_HEAD(, dispatch_unote_linkage_s) dmn_readers_head; TAILQ_HEAD(, dispatch_unote_linkage_s) dmn_writers_head; int dmn_fd; - int dmn_ident; + uint32_t dmn_ident; uint32_t dmn_events; int16_t dmn_filter; bool dmn_skip_outq_ioctl; @@ -85,9 +85,9 @@ static struct dispatch_epoll_timeout_s _dispatch_epoll_timeout[] = { DISPATCH_ALWAYS_INLINE static inline struct dispatch_muxnote_bucket_s * -_dispatch_muxnote_bucket(int ident) +_dispatch_muxnote_bucket(uint32_t ident) { - return &_dispatch_sources[DSL_HASH((uint32_t)ident)]; + return &_dispatch_sources[DSL_HASH(ident)]; } #define _dispatch_unote_muxnote_bucket(du) \ _dispatch_muxnote_bucket(du._du->du_ident) @@ -95,7 +95,7 @@ _dispatch_muxnote_bucket(int ident) DISPATCH_ALWAYS_INLINE static inline dispatch_muxnote_t _dispatch_muxnote_find(struct dispatch_muxnote_bucket_s *dmb, - uint64_t ident, int16_t filter) + uint32_t ident, int16_t filter) { dispatch_muxnote_t dmn; if (filter == EVFILT_WRITE) filter = EVFILT_READ; @@ -112,7 +112,7 @@ _dispatch_muxnote_find(struct dispatch_muxnote_bucket_s *dmb, static void _dispatch_muxnote_dispose(dispatch_muxnote_t dmn) { - if (dmn->dmn_filter != EVFILT_READ || dmn->dmn_fd != dmn->dmn_ident) { + if (dmn->dmn_filter != EVFILT_READ || (uint32_t)dmn->dmn_fd != dmn->dmn_ident) { close(dmn->dmn_fd); } free(dmn); @@ -142,26 +142,27 @@ _dispatch_muxnote_create(dispatch_unote_t du, uint32_t events) dispatch_muxnote_t dmn; struct stat sb; - int fd = du._du->du_ident; + int fd = (int)du._du->du_ident; int16_t filter = du._du->du_filter; bool skip_outq_ioctl = false, skip_inq_ioctl = false; sigset_t sigmask; switch (filter) { - case EVFILT_SIGNAL: - if (!sigismember(&signals_with_unotes, du._du->du_ident)) { + case EVFILT_SIGNAL: { + int signo = (int)du._du->du_ident; + if (!sigismember(&signals_with_unotes, signo)) { manager_thread = pthread_self(); - sigaddset(&signals_with_unotes, du._du->du_ident); - sigaction(du._du->du_ident, &sa, NULL); + sigaddset(&signals_with_unotes, signo); + sigaction(signo, &sa, NULL); } sigemptyset(&sigmask); - sigaddset(&sigmask, du._du->du_ident); + sigaddset(&sigmask, signo); fd = signalfd(-1, &sigmask, SFD_NONBLOCK | SFD_CLOEXEC); if (fd < 0) { return NULL; } break; - + } case EVFILT_WRITE: filter = EVFILT_READ; case EVFILT_READ: @@ -290,7 +291,7 @@ _dispatch_unote_resume(dispatch_unote_t du) } bool -_dispatch_unote_unregister(dispatch_unote_t du, uint32_t flags) +_dispatch_unote_unregister(dispatch_unote_t du, DISPATCH_UNUSED uint32_t flags) { switch (du._du->du_filter) { case DISPATCH_EVFILT_CUSTOM_ADD: @@ -313,10 +314,10 @@ _dispatch_unote_unregister(dispatch_unote_t du, uint32_t flags) dul->du_muxnote = NULL; if (TAILQ_EMPTY(&dmn->dmn_readers_head)) { - events &= ~EPOLLIN; + events &= (uint32_t)(~EPOLLIN); } if (TAILQ_EMPTY(&dmn->dmn_writers_head)) { - events &= ~EPOLLOUT; + events &= (uint32_t)(~EPOLLOUT); } if (events == dmn->dmn_events) { @@ -350,7 +351,8 @@ _dispatch_event_merge_timer(dispatch_clock_t clock) } static void -_dispatch_timeout_program(uint32_t tidx, uint64_t target, uint64_t leeway) +_dispatch_timeout_program(uint32_t tidx, uint64_t target, + DISPATCH_UNUSED uint64_t leeway) { dispatch_clock_t clock = DISPATCH_TIMER_CLOCK(tidx); dispatch_epoll_timeout_t timer = &_dispatch_epoll_timeout[clock]; @@ -358,24 +360,24 @@ _dispatch_timeout_program(uint32_t tidx, uint64_t target, uint64_t leeway) .events = EPOLLONESHOT | EPOLLIN, .data = { .u32 = timer->det_ident }, }; - unsigned long op; + int op; if (target >= INT64_MAX && !timer->det_registered) { return; } if (unlikely(timer->det_fd < 0)) { - clockid_t clock; + clockid_t clockid; int fd; switch (DISPATCH_TIMER_CLOCK(tidx)) { case DISPATCH_CLOCK_MACH: - clock = CLOCK_MONOTONIC; + clockid = CLOCK_MONOTONIC; break; case DISPATCH_CLOCK_WALL: - clock = CLOCK_REALTIME; + clockid = CLOCK_REALTIME; break; } - fd = timerfd_create(clock, TFD_NONBLOCK | TFD_CLOEXEC); + fd = timerfd_create(clockid, TFD_NONBLOCK | TFD_CLOEXEC); if (!dispatch_assume(fd >= 0)) { return; } @@ -451,7 +453,7 @@ _dispatch_epoll_init(void *context DISPATCH_UNUSED) .events = EPOLLIN | EPOLLFREE, .data = { .u32 = DISPATCH_EPOLL_EVENTFD, }, }; - unsigned long op = EPOLL_CTL_ADD; + int op = EPOLL_CTL_ADD; if (epoll_ctl(_dispatch_epfd, op, _dispatch_eventfd, &ev) < 0) { DISPATCH_INTERNAL_CRASH(errno, "epoll_ctl() failed"); } @@ -504,7 +506,7 @@ _dispatch_get_buffer_size(dispatch_muxnote_t dmn, bool writer) return 1; } - if (ioctl(dmn->dmn_ident, writer ? SIOCOUTQ : SIOCINQ, &n) != 0) { + if (ioctl((int)dmn->dmn_ident, writer ? SIOCOUTQ : SIOCINQ, &n) != 0) { switch (errno) { case EINVAL: case ENOTTY: diff --git a/src/event/workqueue.c b/src/event/workqueue.c index dbc65938c..73362a58a 100644 --- a/src/event/workqueue.c +++ b/src/event/workqueue.c @@ -22,9 +22,6 @@ #if DISPATCH_USE_INTERNAL_WORKQUEUE -// forward looking typedef; not yet defined in dispatch -typedef pid_t dispatch_tid; - /* * dispatch_workq monitors the thread pool that is * executing the work enqueued on libdispatch's pthread @@ -88,7 +85,7 @@ _dispatch_workq_worker_register(dispatch_queue_t root_q, qos_class_t cls) dispatch_qos_t qos = _dispatch_qos_from_qos_class(cls); dispatch_workq_monitor_t mon = &_dispatch_workq_monitors[qos-1]; dispatch_assert(mon->dq == root_q); - dispatch_tid tid = _dispatch_thread_getspecific(tid); + dispatch_tid tid = _dispatch_tid_self(); _dispatch_unfair_lock_lock(&mon->registered_tid_lock); dispatch_assert(mon->num_registered_tids < WORKQ_MAX_TRACKED_TIDS-1); int worker_id = mon->num_registered_tids++; @@ -103,7 +100,8 @@ _dispatch_workq_worker_unregister(dispatch_queue_t root_q, qos_class_t cls) #if HAVE_DISPATCH_WORKQ_MONITORING dispatch_qos_t qos = _dispatch_qos_from_qos_class(cls); dispatch_workq_monitor_t mon = &_dispatch_workq_monitors[qos-1]; - dispatch_tid tid = _dispatch_thread_getspecific(tid); + dispatch_assert(mon->dq == root_q); + dispatch_tid tid = _dispatch_tid_self(); _dispatch_unfair_lock_lock(&mon->registered_tid_lock); for (int i = 0; i < mon->num_registered_tids; i++) { if (mon->registered_tids[i] == tid) { @@ -138,10 +136,10 @@ _dispatch_workq_count_runnable_workers(dispatch_workq_monitor_t mon) for (int i = 0; i < mon->num_registered_tids; i++) { dispatch_tid tid = mon->registered_tids[i]; int fd; - size_t bytes_read = -1; + ssize_t bytes_read = -1; int r = snprintf(path, sizeof(path), "/proc/%d/stat", tid); - dispatch_assert(r > 0 && r < sizeof(path)); + dispatch_assert(r > 0 && r < (int)sizeof(path)); fd = open(path, O_RDONLY | O_NONBLOCK); if (unlikely(fd == -1)) { @@ -179,7 +177,7 @@ _dispatch_workq_count_runnable_workers(dispatch_workq_monitor_t mon) static void _dispatch_workq_monitor_pools(void *context DISPATCH_UNUSED) { - int global_soft_max = WORKQ_OVERSUBSCRIBE_FACTOR * dispatch_hw_config(active_cpus); + int global_soft_max = WORKQ_OVERSUBSCRIBE_FACTOR * (int)dispatch_hw_config(active_cpus); int global_runnable = 0; for (dispatch_qos_t i = DISPATCH_QOS_MAX; i > DISPATCH_QOS_UNSPECIFIED; i--) { dispatch_workq_monitor_t mon = &_dispatch_workq_monitors[i-1]; @@ -228,7 +226,7 @@ static void _dispatch_workq_init_once(void *context DISPATCH_UNUSED) { #if HAVE_DISPATCH_WORKQ_MONITORING - int target_runnable = dispatch_hw_config(active_cpus); + int target_runnable = (int)dispatch_hw_config(active_cpus); for (dispatch_qos_t i = DISPATCH_QOS_MAX; i > DISPATCH_QOS_UNSPECIFIED; i--) { dispatch_workq_monitor_t mon = &_dispatch_workq_monitors[i-1]; mon->dq = _dispatch_get_root_queue(i, false); diff --git a/src/internal.h b/src/internal.h index 0536db107..3f481aad7 100644 --- a/src/internal.h +++ b/src/internal.h @@ -394,9 +394,9 @@ DISPATCH_EXPORT DISPATCH_NOTHROW void dispatch_atfork_child(void); DISPATCH_EXPORT DISPATCH_NOINLINE void _dispatch_bug(size_t line, long val); -#if HAVE_MACH DISPATCH_NOINLINE void _dispatch_bug_client(const char* msg); +#if HAVE_MACH DISPATCH_NOINLINE void _dispatch_bug_mach_client(const char *msg, mach_msg_return_t kr); #endif // HAVE_MACH @@ -466,7 +466,9 @@ void _dispatch_log(const char *msg, ...); } \ } while (0) #else -static inline void _dispatch_assert(long e, long line) { +static inline void +_dispatch_assert(long e, size_t line) +{ if (DISPATCH_DEBUG && !e) _dispatch_abort(line, e); } #define dispatch_assert(e) _dispatch_assert((long)(e), __LINE__) @@ -488,7 +490,9 @@ static inline void _dispatch_assert(long e, long line) { } \ } while (0) #else -static inline void _dispatch_assert_zero(long e, long line) { +static inline void +_dispatch_assert_zero(long e, size_t line) +{ if (DISPATCH_DEBUG && e) _dispatch_abort(line, e); } #define dispatch_assert_zero(e) _dispatch_assert_zero((long)(e), __LINE__) @@ -512,7 +516,9 @@ static inline void _dispatch_assert_zero(long e, long line) { _e; \ }) #else -static inline long _dispatch_assume(long e, long line) { +static inline long +_dispatch_assume(long e, long line) +{ if (!e) _dispatch_bug(line, e); return e; } @@ -535,7 +541,9 @@ static inline long _dispatch_assume(long e, long line) { _e; \ }) #else -static inline long _dispatch_assume_zero(long e, long line) { +static inline long +_dispatch_assume_zero(long e, long line) +{ if (e) _dispatch_bug(line, e); return e; } @@ -850,7 +858,7 @@ _dispatch_ktrace_impl(uint32_t code, uint64_t a, uint64_t b, #define _dispatch_hardware_crash() \ __asm__(""); __builtin_trap() // -#define _dispatch_set_crash_log_cause_and_message(ac, msg) +#define _dispatch_set_crash_log_cause_and_message(ac, msg) ((void)(ac)) #define _dispatch_set_crash_log_message(msg) #define _dispatch_set_crash_log_message_dynamic(msg) diff --git a/src/io.c b/src/io.c index 290437371..155b6cf02 100644 --- a/src/io.c +++ b/src/io.c @@ -25,7 +25,7 @@ #endif #ifndef PAGE_SIZE -#define PAGE_SIZE getpagesize() +#define PAGE_SIZE ((size_t)getpagesize()) #endif #if DISPATCH_DATA_IS_BRIDGED_TO_NSDATA @@ -1372,7 +1372,7 @@ _dispatch_fd_entry_create_with_fd(dispatch_fd_t fd, uintptr_t hash) break; ); } - int32_t dev = major(st.st_dev); + dev_t dev = major(st.st_dev); // We have to get the disk on the global dev queue. The // barrier queue cannot continue until that is complete dispatch_suspend(fd_entry->barrier_queue); @@ -2167,7 +2167,7 @@ _dispatch_operation_advise(dispatch_operation_t op, size_t chunk_size) op->advise_offset += advise.ra_count; #ifdef __linux__ _dispatch_io_syscall_switch(err, - readahead(op->fd_entry->fd, advise.ra_offset, advise.ra_count), + readahead(op->fd_entry->fd, advise.ra_offset, (size_t)advise.ra_count), case EINVAL: break; // fd does refer to a non-supported filetype default: (void)dispatch_assume_zero(err); break; ); diff --git a/src/queue.c b/src/queue.c index 2406e7e7b..fe26ab71d 100644 --- a/src/queue.c +++ b/src/queue.c @@ -5329,6 +5329,8 @@ _dispatch_root_queue_push(dispatch_queue_t rq, dispatch_object_t dou, if (_dispatch_root_queue_push_needs_override(rq, qos)) { return _dispatch_root_queue_push_override(rq, dou, qos); } +#else + (void)qos; #endif _dispatch_root_queue_push_inline(rq, dou, dou, 1); } @@ -5870,7 +5872,7 @@ _dispatch_worker_thread(void *context) #if DISPATCH_USE_INTERNAL_WORKQUEUE if (monitored) { - _dispatch_workq_worker_unregister(dq, qc->dgq_qos); + _dispatch_workq_worker_unregister(dq, qc->dgq_qos); } #endif (void)os_atomic_inc2o(qc, dgq_thread_pool_size, release); @@ -5962,6 +5964,7 @@ _dispatch_runloop_root_queue_wakeup_4CF(dispatch_queue_t dq) _dispatch_runloop_queue_wakeup(dq, 0, false); } +#if TARGET_OS_MAC dispatch_runloop_handle_t _dispatch_runloop_root_queue_get_port_4CF(dispatch_queue_t dq) { @@ -5970,6 +5973,7 @@ _dispatch_runloop_root_queue_get_port_4CF(dispatch_queue_t dq) } return _dispatch_runloop_queue_get_handle(dq); } +#endif static void _dispatch_runloop_queue_handle_init(void *ctxt) diff --git a/src/shims/hw_config.h b/src/shims/hw_config.h index 26856bce9..485dad663 100644 --- a/src/shims/hw_config.h +++ b/src/shims/hw_config.h @@ -101,7 +101,7 @@ _dispatch_hw_get_config(_dispatch_hw_config_t c) switch (c) { case _dispatch_hw_config_logical_cpus: case _dispatch_hw_config_physical_cpus: - return sysconf(_SC_NPROCESSORS_CONF); + return (uint32_t)sysconf(_SC_NPROCESSORS_CONF); case _dispatch_hw_config_active_cpus: { #ifdef __USE_GNU @@ -110,9 +110,9 @@ _dispatch_hw_get_config(_dispatch_hw_config_t c) // is restricted to a subset of the online cpus (eg via numactl). cpu_set_t cpuset; if (pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset) == 0) - return CPU_COUNT(&cpuset); + return (uint32_t)CPU_COUNT(&cpuset); #endif - return sysconf(_SC_NPROCESSORS_ONLN); + return (uint32_t)sysconf(_SC_NPROCESSORS_ONLN); } } #else diff --git a/src/shims/lock.c b/src/shims/lock.c index 617fa016d..24af953c3 100644 --- a/src/shims/lock.c +++ b/src/shims/lock.c @@ -382,7 +382,7 @@ _dispatch_futex(uint32_t *uaddr, int op, uint32_t val, const struct timespec *timeout, uint32_t *uaddr2, uint32_t val3, int opflags) { - return syscall(SYS_futex, uaddr, op | opflags, val, timeout, uaddr2, val3); + return (int)syscall(SYS_futex, uaddr, op | opflags, val, timeout, uaddr2, val3); } static int @@ -401,7 +401,7 @@ _dispatch_futex_wake(uint32_t *uaddr, int wake, int opflags) { int rc; _dlock_syscall_switch(err, - rc = _dispatch_futex(uaddr, FUTEX_WAKE, wake, NULL, NULL, 0, opflags), + rc = _dispatch_futex(uaddr, FUTEX_WAKE, (uint32_t)wake, NULL, NULL, 0, opflags), case 0: return; default: DISPATCH_CLIENT_CRASH(err, "futex_wake() failed"); ); @@ -412,7 +412,7 @@ _dispatch_futex_lock_pi(uint32_t *uaddr, struct timespec *timeout, int detect, int opflags) { _dlock_syscall_switch(err, - _dispatch_futex(uaddr, FUTEX_LOCK_PI, detect, timeout, + _dispatch_futex(uaddr, FUTEX_LOCK_PI, (uint32_t)detect, timeout, NULL, 0, opflags), case 0: return; default: DISPATCH_CLIENT_CRASH(errno, "futex_lock_pi() failed"); @@ -606,6 +606,7 @@ _dispatch_gate_wait_slow(dispatch_gate_t dgl, dispatch_lock value, _dispatch_thread_switch(new_value, flags, timeout++); #endif (void)timeout; + (void)flags; } } diff --git a/src/shims/lock.h b/src/shims/lock.h index 0c089aafd..37a3ecfc8 100644 --- a/src/shims/lock.h +++ b/src/shims/lock.h @@ -62,7 +62,7 @@ _dispatch_lock_owner(dispatch_lock lock_value) #include #include /* For SYS_xxx definitions */ -typedef pid_t dispatch_tid; +typedef uint32_t dispatch_tid; typedef uint32_t dispatch_lock; #define DLOCK_OWNER_MASK ((dispatch_lock)FUTEX_TID_MASK) @@ -174,8 +174,8 @@ typedef sem_t _dispatch_sema4_t; #define _DSEMA4_TIMEOUT() ((errno) = ETIMEDOUT, -1) void _dispatch_sema4_init(_dispatch_sema4_t *sema, int policy); -#define _dispatch_sema4_is_created(sema) 1 -#define _dispatch_sema4_create_slow(sema, policy) ((void)0) +#define _dispatch_sema4_is_created(sema) ((void)sema, 1) +#define _dispatch_sema4_create_slow(sema, policy) ((void)sema, (void)policy) #elif USE_WIN32_SEM diff --git a/src/swift/DispatchStubs.cc b/src/swift/DispatchStubs.cc index 1eaf4bd93..9c667d570 100644 --- a/src/swift/DispatchStubs.cc +++ b/src/swift/DispatchStubs.cc @@ -65,6 +65,29 @@ static void _dispatch_overlay_constructor() { #define SWIFT_CC_swift #endif +extern "C" dispatch_queue_attr_t _swift_dispatch_queue_concurrent(void); +extern "C" void _swift_dispatch_apply_current(size_t iterations, __attribute__((__noescape__)) void (^block)(size_t)); +extern "C" dispatch_queue_t _swift_dispatch_get_main_queue(void); +extern "C" dispatch_data_t _swift_dispatch_data_empty(void); +extern "C" dispatch_block_t _swift_dispatch_data_destructor_default(void); +extern "C" dispatch_block_t _swift_dispatch_data_destructor_free(void); +extern "C" dispatch_block_t _swift_dispatch_data_destructor_munmap(void); +extern "C" dispatch_block_t _swift_dispatch_block_create_with_qos_class(dispatch_block_flags_t flags, dispatch_qos_class_t qos, int relative_priority, dispatch_block_t block); +extern "C" dispatch_block_t _swift_dispatch_block_create_noescape(dispatch_block_flags_t flags, dispatch_block_t block); +extern "C" void _swift_dispatch_block_cancel(dispatch_block_t block); +extern "C" long _swift_dispatch_block_wait(dispatch_block_t block, dispatch_time_t timeout); +extern "C" void _swift_dispatch_block_notify(dispatch_block_t block, dispatch_queue_t queue, dispatch_block_t notification_block); +extern "C" long _swift_dispatch_block_testcancel(dispatch_block_t block); +extern "C" void _swift_dispatch_async(dispatch_queue_t queue, dispatch_block_t block); +extern "C" void _swift_dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block); +extern "C" void _swift_dispatch_sync(dispatch_queue_t queue, dispatch_block_t block); +extern "C" void _swift_dispatch_release(dispatch_object_t obj); +extern "C" void _swift_dispatch_retain(dispatch_object_t obj); +#if !USE_OBJC +extern "C" void * objc_retainAutoreleasedReturnValue(void *obj); +#endif + + SWIFT_CC(swift) DISPATCH_RUNTIME_STDLIB_INTERFACE extern "C" dispatch_queue_attr_t _swift_dispatch_queue_concurrent(void) { @@ -174,6 +197,7 @@ _swift_dispatch_retain(dispatch_object_t obj) { } #define SOURCE(t) \ + extern "C" dispatch_source_type_t _swift_dispatch_source_type_##t(void); \ SWIFT_CC(swift) \ DISPATCH_RUNTIME_STDLIB_INTERFACE extern "C" dispatch_source_type_t \ _swift_dispatch_source_type_##t(void) { \ diff --git a/src/voucher.c b/src/voucher.c index 5beadf0f1..e4128a289 100644 --- a/src/voucher.c +++ b/src/voucher.c @@ -1550,12 +1550,14 @@ _voucher_create_accounting_voucher(voucher_t voucher) return NULL; } +#if HAVE_MACH voucher_t voucher_create_with_mach_msg(mach_msg_header_t *msg) { (void)msg; return NULL; } +#endif #if VOUCHER_ENABLE_GET_MACH_VOUCHER mach_voucher_t