5 files changed, 170 insertions, 134 deletions

diff --git a/include/err.h b/include/err.h
index b6ab2147ef0d..b0e312160f87 100644
--- a/include/err.h
+++ b/include/err.h
@@ -43,6 +43,8 @@
 #include <sys/cdefs.h>
 #include <sys/_types.h>
 
+__NULLABILITY_PRAGMA_PUSH
+
 __BEGIN_DECLS
 void	err(int, const char *, ...) __dead2 __printf0like(2, 3);
 void	verr(int, const char *, __va_list) __dead2 __printf0like(2, 0);
@@ -58,7 +60,8 @@ void	vwarnc(int, const char *, __va_list) __printf0like(2, 0);
 void	warnx(const char *, ...) __printflike(1, 2);
 void	vwarnx(const char *, __va_list) __printflike(1, 0);
 void	err_set_file(void *);
-void	err_set_exit(void (*)(int));
+void	err_set_exit(void (* _Nullable)(int));
 __END_DECLS
+__NULLABILITY_PRAGMA_POP
 
 #endif /* !_ERR_H_ */
diff --git a/include/pthread.h b/include/pthread.h
index ff74e0b4e8f6..3f45d6d84299 100644
--- a/include/pthread.h
+++ b/include/pthread.h
@@ -46,6 +46,8 @@
 #include <sched.h>
 #include <time.h>
 
+__NULLABILITY_PRAGMA_PUSH
+
 /*
  * Run-time invariant values:
  */
@@ -147,28 +149,35 @@ struct _pthread_cleanup_info {
  */
 __BEGIN_DECLS
 int		pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
-int		pthread_attr_destroy(pthread_attr_t *);
-int		pthread_attr_getstack(const pthread_attr_t * __restrict, 
-			void ** __restrict, size_t * __restrict);
-int		pthread_attr_getstacksize(const pthread_attr_t *, size_t *);
-int		pthread_attr_getguardsize(const pthread_attr_t *, size_t *);
+int		pthread_attr_destroy(pthread_attr_t * _Nonnull);
+int		pthread_attr_getstack(
+		    const pthread_attr_t * _Nonnull __restrict, 
+		    void ** _Nonnull __restrict,
+		    size_t * _Nonnull __restrict);
+int		pthread_attr_getstacksize(const pthread_attr_t * _Nonnull,
+		    size_t * _Nonnull);
+int		pthread_attr_getguardsize(const pthread_attr_t * _Nonnull,
+		    size_t * _Nonnull);
 int		pthread_attr_getstackaddr(const pthread_attr_t *, void **);
-int		pthread_attr_getdetachstate(const pthread_attr_t *, int *);
-int		pthread_attr_init(pthread_attr_t *);
-int		pthread_attr_setstacksize(pthread_attr_t *, size_t);
-int		pthread_attr_setguardsize(pthread_attr_t *, size_t);
-int		pthread_attr_setstack(pthread_attr_t *, void *, size_t);
+int		pthread_attr_getdetachstate(const pthread_attr_t * _Nonnull,
+		    int * _Nonnull);
+int		pthread_attr_init(pthread_attr_t * _Nonnull);
+int		pthread_attr_setstacksize(pthread_attr_t * _Nonnull, size_t);
+int		pthread_attr_setguardsize(pthread_attr_t * _Nonnull, size_t);
+int		pthread_attr_setstack(pthread_attr_t * _Nonnull, void *,
+		    size_t);
 int		pthread_attr_setstackaddr(pthread_attr_t *, void *);
-int		pthread_attr_setdetachstate(pthread_attr_t *, int);
-int		pthread_barrier_destroy(pthread_barrier_t *);
-int		pthread_barrier_init(pthread_barrier_t *,
+int		pthread_attr_setdetachstate(pthread_attr_t * _Nonnull, int);
+int		pthread_barrier_destroy(pthread_barrier_t * _Nonnull);
+int		pthread_barrier_init(pthread_barrier_t * _Nonnull,
 			const pthread_barrierattr_t *, unsigned);
-int		pthread_barrier_wait(pthread_barrier_t *);
-int		pthread_barrierattr_destroy(pthread_barrierattr_t *);
-int		pthread_barrierattr_getpshared(const pthread_barrierattr_t *,
-			int *);
-int		pthread_barrierattr_init(pthread_barrierattr_t *);
-int		pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
+int		pthread_barrier_wait(pthread_barrier_t * _Nonnull);
+int		pthread_barrierattr_destroy(pthread_barrierattr_t * _Nonnull);
+int		pthread_barrierattr_getpshared(
+		    const pthread_barrierattr_t * _Nonnull, int * _Nonnull);
+int		pthread_barrierattr_init(pthread_barrierattr_t * _Nonnull);
+int		pthread_barrierattr_setpshared(pthread_barrierattr_t * _Nonnull,
+		    int);
 
 #define		pthread_cleanup_push(cleanup_routine, cleanup_arg)		\
 		{								\
@@ -183,100 +192,109 @@ int		pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
 			__pthread_cleanup_pop_imp(execute);			\
 		}
 
-int		pthread_condattr_destroy(pthread_condattr_t *);
-int		pthread_condattr_getclock(const pthread_condattr_t *,
-			clockid_t *);
-int		pthread_condattr_getpshared(const pthread_condattr_t *, int *);
-int		pthread_condattr_init(pthread_condattr_t *);
-int		pthread_condattr_setclock(pthread_condattr_t *, clockid_t);
-int		pthread_condattr_setpshared(pthread_condattr_t *, int);
-int		pthread_cond_broadcast(pthread_cond_t *);
-int		pthread_cond_destroy(pthread_cond_t *);
-int		pthread_cond_init(pthread_cond_t *,
+int		pthread_condattr_destroy(pthread_condattr_t * _Nonnull);
+int		pthread_condattr_getclock(const pthread_condattr_t * _Nonnull,
+		    clockid_t * _Nonnull);
+int		pthread_condattr_getpshared(const pthread_condattr_t * _Nonnull,
+		    int * _Nonnull);
+int		pthread_condattr_init(pthread_condattr_t * _Nonnull);
+int		pthread_condattr_setclock(pthread_condattr_t * _Nonnull,
+		    clockid_t);
+int		pthread_condattr_setpshared(pthread_condattr_t * _Nonnull, int);
+int		pthread_cond_broadcast(pthread_cond_t * _Nonnull);
+int		pthread_cond_destroy(pthread_cond_t * _Nonnull);
+int		pthread_cond_init(pthread_cond_t * _Nonnull,
 			const pthread_condattr_t *);
-int		pthread_cond_signal(pthread_cond_t *);
-int		pthread_cond_timedwait(pthread_cond_t *,
-			pthread_mutex_t *__mutex, const struct timespec *)
+int		pthread_cond_signal(pthread_cond_t * _Nonnull);
+int		pthread_cond_timedwait(pthread_cond_t * _Nonnull,
+		    pthread_mutex_t * _Nonnull __mutex,
+		    const struct timespec * _Nonnull)
 		    __requires_exclusive(*__mutex);
-int		pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *__mutex)
+int		pthread_cond_wait(pthread_cond_t * _Nonnull,
+		    pthread_mutex_t * _Nonnull __mutex)
 		    __requires_exclusive(*__mutex);
-int		pthread_create(pthread_t *, const pthread_attr_t *,
-			void *(*) (void *), void *);
+int		pthread_create(pthread_t * _Nonnull, const pthread_attr_t *,
+		    void *(* _Nonnull) (void *), void *);
 int		pthread_detach(pthread_t);
 int		pthread_equal(pthread_t, pthread_t);
 void		pthread_exit(void *) __dead2;
 void		*pthread_getspecific(pthread_key_t);
-int		pthread_getcpuclockid(pthread_t, clockid_t *);
+int		pthread_getcpuclockid(pthread_t, clockid_t * _Nonnull);
 int		pthread_join(pthread_t, void **);
-int		pthread_key_create(pthread_key_t *,
-			void (*) (void *));
+int		pthread_key_create(pthread_key_t * _Nonnull,
+		    void (*) (void *));
 int		pthread_key_delete(pthread_key_t);
-int		pthread_mutexattr_init(pthread_mutexattr_t *);
-int		pthread_mutexattr_destroy(pthread_mutexattr_t *);
-int		pthread_mutexattr_getpshared(const pthread_mutexattr_t *,
-			int *);
-int		pthread_mutexattr_gettype(pthread_mutexattr_t *, int *);
-int		pthread_mutexattr_settype(pthread_mutexattr_t *, int);
-int		pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
-int		pthread_mutex_consistent(pthread_mutex_t *__mutex)
-			__nonnull(1) __requires_exclusive(*__mutex);
-int		pthread_mutex_destroy(pthread_mutex_t *__mutex)
+int		pthread_mutexattr_init(pthread_mutexattr_t * _Nonnull);
+int		pthread_mutexattr_destroy(pthread_mutexattr_t * _Nonnull);
+int		pthread_mutexattr_getpshared(
+		    const pthread_mutexattr_t * _Nonnull, int * _Nonnull);
+int		pthread_mutexattr_gettype(pthread_mutexattr_t * _Nonnull,
+		    int * _Nonnull);
+int		pthread_mutexattr_settype(pthread_mutexattr_t * _Nonnull, int);
+int		pthread_mutexattr_setpshared(pthread_mutexattr_t * _Nonnull,
+		    int);
+int		pthread_mutex_consistent(pthread_mutex_t * _Nonnull __mutex)
+		    __requires_exclusive(*__mutex);
+int		pthread_mutex_destroy(pthread_mutex_t * _Nonnull __mutex)
 		    __requires_unlocked(*__mutex);
-int		pthread_mutex_init(pthread_mutex_t *__mutex,
-			const pthread_mutexattr_t *)
+int		pthread_mutex_init(pthread_mutex_t * _Nonnull __mutex,
+		    const pthread_mutexattr_t *)
 		    __requires_unlocked(*__mutex);
-int		pthread_mutex_lock(pthread_mutex_t *__mutex)
-                    __locks_exclusive(*__mutex);
-int		pthread_mutex_trylock(pthread_mutex_t *__mutex)
-                    __trylocks_exclusive(0, *__mutex);
-int		pthread_mutex_timedlock(pthread_mutex_t *__mutex,
-			const struct timespec *)
-                    __trylocks_exclusive(0, *__mutex);
-int		pthread_mutex_unlock(pthread_mutex_t *__mutex)
+int		pthread_mutex_lock(pthread_mutex_t * _Nonnull __mutex)
+		    __locks_exclusive(*__mutex);
+int		pthread_mutex_trylock(pthread_mutex_t * _Nonnull __mutex)
+		    __trylocks_exclusive(0, *__mutex);
+int		pthread_mutex_timedlock(pthread_mutex_t * _Nonnull __mutex,
+		    const struct timespec * _Nonnull)
+		    __trylocks_exclusive(0, *__mutex);
+int		pthread_mutex_unlock(pthread_mutex_t * _Nonnull __mutex)
 		    __unlocks(*__mutex);
-int		pthread_once(pthread_once_t *, void (*) (void));
-int		pthread_rwlock_destroy(pthread_rwlock_t *__rwlock)
+int		pthread_once(pthread_once_t * _Nonnull,
+		    void (* _Nonnull) (void));
+int		pthread_rwlock_destroy(pthread_rwlock_t * _Nonnull __rwlock)
 		    __requires_unlocked(*__rwlock);
-int		pthread_rwlock_init(pthread_rwlock_t *__rwlock,
-			const pthread_rwlockattr_t *)
+int		pthread_rwlock_init(pthread_rwlock_t * _Nonnull __rwlock,
+		    const pthread_rwlockattr_t *)
 		    __requires_unlocked(*__rwlock);
-int		pthread_rwlock_rdlock(pthread_rwlock_t *__rwlock)
-                    __locks_shared(*__rwlock);
-int		pthread_rwlock_timedrdlock(pthread_rwlock_t *__rwlock,
-			const struct timespec *)
-                    __trylocks_shared(0, *__rwlock);
-int		pthread_rwlock_timedwrlock(pthread_rwlock_t *__rwlock,
-			const struct timespec *)
-                    __trylocks_exclusive(0, *__rwlock);
-int		pthread_rwlock_tryrdlock(pthread_rwlock_t *__rwlock)
-                    __trylocks_shared(0, *__rwlock);
-int		pthread_rwlock_trywrlock(pthread_rwlock_t *__rwlock)
-                    __trylocks_exclusive(0, *__rwlock);
-int		pthread_rwlock_unlock(pthread_rwlock_t *__rwlock)
+int		pthread_rwlock_rdlock(pthread_rwlock_t * _Nonnull __rwlock)
+		    __locks_shared(*__rwlock);
+int		pthread_rwlock_timedrdlock(pthread_rwlock_t * _Nonnull __rwlock,
+		    const struct timespec * _Nonnull)
+		    __trylocks_shared(0, *__rwlock);
+int		pthread_rwlock_timedwrlock(pthread_rwlock_t * _Nonnull __rwlock,
+		    const struct timespec * _Nonnull)
+		    __trylocks_exclusive(0, *__rwlock);
+int		pthread_rwlock_tryrdlock(pthread_rwlock_t * _Nonnull __rwlock)
+		    __trylocks_shared(0, *__rwlock);
+int		pthread_rwlock_trywrlock(pthread_rwlock_t * _Nonnull __rwlock)
+		    __trylocks_exclusive(0, *__rwlock);
+int		pthread_rwlock_unlock(pthread_rwlock_t * _Nonnull __rwlock)
 		    __unlocks(*__rwlock);
-int		pthread_rwlock_wrlock(pthread_rwlock_t *__rwlock)
-                    __locks_exclusive(*__rwlock);
-int		pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
-int		pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *,
-			int *);
-int		pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *,
-			int *);
-int		pthread_rwlockattr_init(pthread_rwlockattr_t *);
-int		pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *, int);
-int		pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
+int		pthread_rwlock_wrlock(pthread_rwlock_t * _Nonnull __rwlock)
+		    __locks_exclusive(*__rwlock);
+int		pthread_rwlockattr_destroy(pthread_rwlockattr_t * _Nonnull);
+int		pthread_rwlockattr_getkind_np(
+		    const pthread_rwlockattr_t * _Nonnull, int *);
+int		pthread_rwlockattr_getpshared(
+		    const pthread_rwlockattr_t * _Nonnull, int * _Nonnull);
+int		pthread_rwlockattr_init(pthread_rwlockattr_t * _Nonnull);
+int		pthread_rwlockattr_setkind_np(pthread_rwlockattr_t * _Nonnull,
+		    int);
+int		pthread_rwlockattr_setpshared(pthread_rwlockattr_t * _Nonnull,
+		    int);
 pthread_t	pthread_self(void);
 int		pthread_setspecific(pthread_key_t, const void *);
 
-int		pthread_spin_init(pthread_spinlock_t *__spin, int)
+int		pthread_spin_init(pthread_spinlock_t * _Nonnull __spin, int)
 		    __requires_unlocked(*__spin);
-int		pthread_spin_destroy(pthread_spinlock_t *__spin)
+int		pthread_spin_destroy(pthread_spinlock_t * _Nonnull __spin)
 		    __requires_unlocked(*__spin);
-int		pthread_spin_lock(pthread_spinlock_t *__spin)
-                    __locks_exclusive(*__spin);
-int		pthread_spin_trylock(pthread_spinlock_t *__spin)
-                    __trylocks_exclusive(0, *__spin);
-int		pthread_spin_unlock(pthread_spinlock_t *__spin)
-		    __unlocks(*__spin);
+int		pthread_spin_lock(pthread_spinlock_t * _Nonnull __spin)
+			__locks_exclusive(*__spin);
+int		pthread_spin_trylock(pthread_spinlock_t * _Nonnull __spin)
+			__trylocks_exclusive(0, *__spin);
+int		pthread_spin_unlock(pthread_spinlock_t * _Nonnull __spin)
+			__unlocks(*__spin);
 int		pthread_cancel(pthread_t);
 int		pthread_setcancelstate(int, int *);
 int		pthread_setcanceltype(int, int *);
@@ -288,35 +306,36 @@ int		pthread_setprio(pthread_t, int);
 void		pthread_yield(void);
 #endif
 
-int		pthread_mutexattr_getprioceiling(pthread_mutexattr_t *,
-			int *);
-int		pthread_mutexattr_setprioceiling(pthread_mutexattr_t *,
-			int);
+int		pthread_mutexattr_getprioceiling(pthread_mutexattr_t *, int *);
+int		pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
 int		pthread_mutex_getprioceiling(pthread_mutex_t *, int *);
 int		pthread_mutex_setprioceiling(pthread_mutex_t *, int, int *);
 
 int		pthread_mutexattr_getprotocol(pthread_mutexattr_t *, int *);
 int		pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
 
-int		pthread_mutexattr_getrobust(pthread_mutexattr_t *__restrict,
-			int *__restrict) __nonnull_all;
-int		pthread_mutexattr_setrobust(pthread_mutexattr_t *, int)
-			__nonnull(1);
+int		pthread_mutexattr_getrobust(
+		    pthread_mutexattr_t * _Nonnull __restrict,
+		    int * _Nonnull __restrict);
+int		pthread_mutexattr_setrobust(pthread_mutexattr_t * _Nonnull,
+		    int);
 
 int		pthread_attr_getinheritsched(const pthread_attr_t *, int *);
-int		pthread_attr_getschedparam(const pthread_attr_t *,
-			struct sched_param *);
-int		pthread_attr_getschedpolicy(const pthread_attr_t *, int *);
-int		pthread_attr_getscope(const pthread_attr_t *, int *);
+int		pthread_attr_getschedparam(const pthread_attr_t * _Nonnull,
+		    struct sched_param * _Nonnull);
+int		pthread_attr_getschedpolicy(const pthread_attr_t * _Nonnull,
+		    int * _Nonnull);
+int		pthread_attr_getscope(const pthread_attr_t * _Nonnull,
+		    int * _Nonnull);
 int		pthread_attr_setinheritsched(pthread_attr_t *, int);
-int		pthread_attr_setschedparam(pthread_attr_t *,
-			const struct sched_param *);
-int		pthread_attr_setschedpolicy(pthread_attr_t *, int);
-int		pthread_attr_setscope(pthread_attr_t *, int);
-int		pthread_getschedparam(pthread_t pthread, int *,
-			struct sched_param *);
+int		pthread_attr_setschedparam(pthread_attr_t * _Nonnull,
+		    const struct sched_param * _Nonnull);
+int		pthread_attr_setschedpolicy(pthread_attr_t * _Nonnull, int);
+int		pthread_attr_setscope(pthread_attr_t * _Nonnull, int);
+int		pthread_getschedparam(pthread_t pthread, int * _Nonnull,
+		    struct sched_param * _Nonnull);
 int		pthread_setschedparam(pthread_t, int,
-			const struct sched_param *);
+		    const struct sched_param * _Nonnull);
 #if __XSI_VISIBLE
 int		pthread_getconcurrency(void);
 int		pthread_setconcurrency(int);
@@ -326,5 +345,6 @@ void		__pthread_cleanup_push_imp(void (*)(void *), void *,
 			struct _pthread_cleanup_info *);
 void		__pthread_cleanup_pop_imp(int);
 __END_DECLS
+__NULLABILITY_PRAGMA_POP
 
-#endif
+#endif	/* _PTHREAD_H_ */
diff --git a/include/signal.h b/include/signal.h
index 9d874de3632a..f9b6923c4345 100644
--- a/include/signal.h
+++ b/include/signal.h
@@ -41,6 +41,8 @@
 #include <sys/_ucontext.h>
 #endif
 
+__NULLABILITY_PRAGMA_PUSH
+
 #if __BSD_VISIBLE
 /*
  * XXX should enlarge these, if only to give empty names instead of bounds
@@ -82,10 +84,11 @@ int	sigdelset(sigset_t *, int);
 int	sigemptyset(sigset_t *);
 int	sigfillset(sigset_t *);
 int	sigismember(const sigset_t *, int);
-int	sigpending(sigset_t *);
+int	sigpending(sigset_t * _Nonnull);
 int	sigprocmask(int, const sigset_t * __restrict, sigset_t * __restrict);
-int	sigsuspend(const sigset_t *);
-int	sigwait(const sigset_t * __restrict, int * __restrict);
+int	sigsuspend(const sigset_t * _Nonnull);
+int	sigwait(const sigset_t * _Nonnull __restrict,
+	    int * _Nonnull __restrict);
 #endif
 
 #if __POSIX_VISIBLE >= 199506 || __XSI_VISIBLE >= 600
@@ -104,7 +107,7 @@ int	sighold(int);
 int	sigignore(int);
 int	sigpause(int);
 int	sigrelse(int);
-void	(*sigset(int, void (*)(int)))(int);
+void	(* _Nullable sigset(int, void (* _Nullable)(int)))(int);
 int	xsi_sigpause(int);
 #endif
 
@@ -124,5 +127,6 @@ int	sigstack(const struct sigstack *, struct sigstack *);
 int	sigvec(int, struct sigvec *, struct sigvec *);
 #endif
 __END_DECLS
+__NULLABILITY_PRAGMA_POP
 
 #endif /* !_SIGNAL_H_ */
diff --git a/include/stdio.h b/include/stdio.h
index 5950625ec2f6..99773885f1f5 100644
--- a/include/stdio.h
+++ b/include/stdio.h
@@ -40,6 +40,8 @@
 #include <sys/_null.h>
 #include <sys/_types.h>
 
+__NULLABILITY_PRAGMA_PUSH
+
 typedef	__off_t		fpos_t;
 
 #ifndef _SIZE_T_DECLARED
@@ -123,10 +125,10 @@ struct __sFILE {
 
 	/* operations */
 	void	*_cookie;	/* (*) cookie passed to io functions */
-	int	(*_close)(void *);
-	int	(*_read)(void *, char *, int);
-	fpos_t	(*_seek)(void *, fpos_t, int);
-	int	(*_write)(void *, const char *, int);
+	int	(* _Nullable _close)(void *);
+	int	(* _Nullable _read)(void *, char *, int);
+	fpos_t	(* _Nullable _seek)(void *, fpos_t, int);
+	int	(* _Nullable _write)(void *, const char *, int);
 
 	/* separate buffer for long sequences of ungetc() */
 	struct	__sbuf _ub;	/* ungetc buffer */
@@ -390,10 +392,10 @@ extern const char * const sys_errlist[];
  * Stdio function-access interface.
  */
 FILE	*funopen(const void *,
-	    int (*)(void *, char *, int),
-	    int (*)(void *, const char *, int),
-	    fpos_t (*)(void *, fpos_t, int),
-	    int (*)(void *));
+	    int (* _Nullable)(void *, char *, int),
+	    int (* _Nullable)(void *, const char *, int),
+	    fpos_t (* _Nullable)(void *, fpos_t, int),
+	    int (* _Nullable)(void *));
 #define	fropen(cookie, fn) funopen(cookie, fn, 0, 0, 0)
 #define	fwopen(cookie, fn) funopen(cookie, 0, fn, 0, 0)
 
@@ -506,4 +508,6 @@ extern int __isthreaded;
 #endif /* __cplusplus */
 
 __END_DECLS
+__NULLABILITY_PRAGMA_POP
+
 #endif /* !_STDIO_H_ */
diff --git a/include/stdlib.h b/include/stdlib.h
index e27f3a220c47..0a2874d99e7a 100644
--- a/include/stdlib.h
+++ b/include/stdlib.h
@@ -37,6 +37,8 @@
 #include <sys/_null.h>
 #include <sys/_types.h>
 
+__NULLABILITY_PRAGMA_PUSH
+
 #if __BSD_VISIBLE
 #ifndef _RUNE_T_DECLARED
 typedef	__rune_t	rune_t;
@@ -81,12 +83,12 @@ extern int ___mb_cur_max(void);
 
 _Noreturn void	 abort(void);
 int	 abs(int) __pure2;
-int	 atexit(void (*)(void));
+int	 atexit(void (* _Nonnull)(void));
 double	 atof(const char *);
 int	 atoi(const char *);
 long	 atol(const char *);
 void	*bsearch(const void *, const void *, size_t,
-	    size_t, int (*)(const void *, const void *));
+	    size_t, int (*)(const void * _Nonnull, const void *));
 void	*calloc(size_t, size_t) __malloc_like __result_use_check
 	     __alloc_size(1) __alloc_size(2);
 div_t	 div(int, int) __pure2;
@@ -100,7 +102,7 @@ int	 mblen(const char *, size_t);
 size_t	 mbstowcs(wchar_t * __restrict , const char * __restrict, size_t);
 int	 mbtowc(wchar_t * __restrict, const char * __restrict, size_t);
 void	 qsort(void *, size_t, size_t,
-	    int (*)(const void *, const void *));
+	    int (* _Nonnull)(const void *, const void *));
 int	 rand(void);
 void	*realloc(void *, size_t) __result_use_check __alloc_size(2);
 void	 srand(unsigned);
@@ -256,9 +258,9 @@ void	 arc4random_stir(void);
 __uint32_t 
 	 arc4random_uniform(__uint32_t);
 #ifdef __BLOCKS__
-int	 atexit_b(void (^)(void));
+int	 atexit_b(void (^ _Nonnull)(void));
 void	*bsearch_b(const void *, const void *, size_t,
-	    size_t, int (^)(const void *, const void *));
+	    size_t, int (^ _Nonnull)(const void *, const void *));
 #endif
 char	*getbsize(int *, long *);
 					/* getcap(3) functions */
@@ -282,11 +284,13 @@ int	 getloadavg(double [], int);
 const char *
 	 getprogname(void);
 
-int	 heapsort(void *, size_t, size_t, int (*)(const void *, const void *));
+int	 heapsort(void *, size_t, size_t,
+	    int (* _Nonnull)(const void *, const void *));
 #ifdef __BLOCKS__
-int	 heapsort_b(void *, size_t, size_t, int (^)(const void *, const void *));
+int	 heapsort_b(void *, size_t, size_t,
+	    int (^ _Nonnull)(const void *, const void *));
 void	 qsort_b(void *, size_t, size_t,
-	    int (^)(const void *, const void *));
+	    int (^ _Nonnull)(const void *, const void *));
 #endif
 int	 l64a_r(long, char *, int);
 int	 mergesort(void *, size_t, size_t, int (*)(const void *, const void *));
@@ -320,5 +324,6 @@ __uint64_t
 extern char *suboptarg;			/* getsubopt(3) external variable */
 #endif /* __BSD_VISIBLE */
 __END_DECLS
+__NULLABILITY_PRAGMA_POP
 
 #endif /* !_STDLIB_H_ */