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 inital
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.

Author: dgrove-oss

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,16 +158,20 @@ 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
 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

src/data.c

@@ -129,6 +129,9 @@ static void
 _dispatch_data_destroy_buffer(const void* buffer, size_t size,
 		dispatch_queue_t queue, dispatch_block_t destructor)
 {
+#if !HAVE_MACH
+	(void)size;
+#endif
 	if (destructor == DISPATCH_DATA_DESTRUCTOR_FREE) {
 		free((void*)buffer);
 	} else if (destructor == DISPATCH_DATA_DESTRUCTOR_NONE) {

src/event/event_epoll.c

@@ -89,12 +89,12 @@ _dispatch_muxnote_bucket(int ident)
 	return &_dispatch_sources[DSL_HASH((uint32_t)ident)];
 }
 #define _dispatch_unote_muxnote_bucket(du) \
-	_dispatch_muxnote_bucket(du._du->du_ident)
+	_dispatch_muxnote_bucket((int)du._du->du_ident)
 
 DISPATCH_ALWAYS_INLINE
 static inline dispatch_muxnote_t
 _dispatch_muxnote_find(struct dispatch_muxnote_bucket_s *dmb,
-		uint64_t ident, int16_t filter)
+		int ident, int16_t filter)
 {
 	dispatch_muxnote_t dmn;
 	if (filter == EVFILT_WRITE) filter = EVFILT_READ;
@@ -106,7 +106,7 @@ _dispatch_muxnote_find(struct dispatch_muxnote_bucket_s *dmb,
 	return dmn;
 }
 #define _dispatch_unote_muxnote_find(dmb, du) \
-		_dispatch_muxnote_find(dmb, du._du->du_ident, du._du->du_filter)
+		_dispatch_muxnote_find(dmb, (int)du._du->du_ident, du._du->du_filter)
 
 static void
 _dispatch_muxnote_dispose(dispatch_muxnote_t dmn)
@@ -141,20 +141,20 @@ _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 socket_listener = false;
 	sigset_t sigmask;
 
 	switch (filter) {
 	case EVFILT_SIGNAL:
-		if (!sigismember(&signals_with_unotes, du._du->du_ident)) {
+		if (!sigismember(&signals_with_unotes, (int)du._du->du_ident)) {
 			manager_thread = pthread_self();
-			sigaddset(&signals_with_unotes, du._du->du_ident);
-			sigaction(du._du->du_ident, &sa, NULL);
+			sigaddset(&signals_with_unotes, (int)du._du->du_ident);
+			sigaction((int)du._du->du_ident, &sa, NULL);
 		}
 		sigemptyset(&sigmask);
-		sigaddset(&sigmask, du._du->du_ident);
+		sigaddset(&sigmask, (int)du._du->du_ident);
 		fd = signalfd(-1, &sigmask, SFD_NONBLOCK | SFD_CLOEXEC);
 		if (fd < 0) {
 			return NULL;
@@ -190,7 +190,7 @@ _dispatch_muxnote_create(dispatch_unote_t du, uint32_t events)
 	TAILQ_INIT(&dmn->dmn_readers_head);
 	TAILQ_INIT(&dmn->dmn_writers_head);
 	dmn->dmn_fd = fd;
-	dmn->dmn_ident = du._du->du_ident;
+	dmn->dmn_ident = (int)du._du->du_ident;
 	dmn->dmn_filter = filter;
 	dmn->dmn_events = events;
 	dmn->dmn_socket_listener = socket_listener;
@@ -284,7 +284,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:
@@ -307,10 +307,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) {
@@ -343,32 +343,32 @@ _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];
 	struct epoll_event ev = {
 		.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;
 		}
@@ -444,7 +444,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");
 	}

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);

src/init.c

@@ -614,13 +614,13 @@ _dispatch_bug(size_t line, long val)
 			_dispatch_build, (unsigned long)line, val);
 }
 
+#if HAVE_MACH
 void
 _dispatch_bug_client(const char* msg)
 {
 	_dispatch_bug_log("BUG in libdispatch client: %s", msg);
 }
 
-#if HAVE_MACH
 void
 _dispatch_bug_mach_client(const char* msg, mach_msg_return_t kr)
 {

src/internal.h

@@ -466,7 +466,7 @@ 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 +488,7 @@ 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__)

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;
 	);

src/queue.c

@@ -5330,6 +5330,7 @@ _dispatch_root_queue_push(dispatch_queue_t rq, dispatch_object_t dou,
 		return _dispatch_root_queue_push_override(rq, dou, qos);
 	}
 #endif
+	(void)qos;
 	_dispatch_root_queue_push_inline(rq, dou, dou, 1);
 }
 
@@ -5870,7 +5871,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 +5963,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 +5972,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)
@@ -6218,6 +6221,7 @@ DISPATCH_NORETURN
 static void
 _dispatch_deferred_items_cleanup(void *ctxt)
 {
+	(void)ctxt;
 	// POSIX defines that destructors are only called if 'ctxt' is non-null
 	DISPATCH_INTERNAL_CRASH(ctxt,
 			"Premature thread exit with unhandled deferred items");
@@ -6227,6 +6231,7 @@ DISPATCH_NORETURN
 static void
 _dispatch_frame_cleanup(void *ctxt)
 {
+	(void)ctxt;
 	// POSIX defines that destructors are only called if 'ctxt' is non-null
 	DISPATCH_INTERNAL_CRASH(ctxt,
 			"Premature thread exit while a dispatch frame is active");
@@ -6236,6 +6241,7 @@ DISPATCH_NORETURN
 static void
 _dispatch_context_cleanup(void *ctxt)
 {
+	(void)ctxt;
 	// POSIX defines that destructors are only called if 'ctxt' is non-null
 	DISPATCH_INTERNAL_CRASH(ctxt,
 			"Premature thread exit while a dispatch context is set");

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