Index: include/err.h
===================================================================
--- include/err.h
+++ include/err.h
@@ -58,7 +58,7 @@
 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
 
 #endif /* !_ERR_H_ */
Index: include/pthread.h
===================================================================
--- include/pthread.h
+++ include/pthread.h
@@ -146,204 +146,192 @@
  * Thread function prototype definitions:
  */
 __BEGIN_DECLS
-int		pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
-int		pthread_attr_destroy(pthread_attr_t *) __nonnull(1);
-int		pthread_attr_getstack(const pthread_attr_t * __restrict, 
-			void ** __restrict, size_t * __restrict)
-			__nonnull_all;
-int		pthread_attr_getstacksize(const pthread_attr_t *, size_t *)
-			__nonnull_all;
-int		pthread_attr_getguardsize(const pthread_attr_t *, size_t *);
-int		pthread_attr_getstackaddr(const pthread_attr_t *, void **);
-int		pthread_attr_getdetachstate(const pthread_attr_t *, int *)
-			__nonnull_all;
-int		pthread_attr_init(pthread_attr_t *) __nonnull(1);
-int		pthread_attr_setstacksize(pthread_attr_t *, size_t)
-			__nonnull(1);
-int		pthread_attr_setguardsize(pthread_attr_t *, size_t)
-			__nonnull(1);
-int		pthread_attr_setstack(pthread_attr_t *, void *, size_t)
-			__nonnull(1);
-int		pthread_attr_setstackaddr(pthread_attr_t *, void *);
-int		pthread_attr_setdetachstate(pthread_attr_t *, int) __nonnull(1);
-int		pthread_barrier_destroy(pthread_barrier_t *);
-int		pthread_barrier_init(pthread_barrier_t *,
-			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 *) __nonnull(1);
-int		pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
-
-#define		pthread_cleanup_push(cleanup_routine, cleanup_arg)		\
-		{								\
-			struct _pthread_cleanup_info __cleanup_info__;		\
-			__pthread_cleanup_push_imp(cleanup_routine, cleanup_arg,\
-				&__cleanup_info__);				\
-			{
-
-#define		pthread_cleanup_pop(execute)					\
-				(void)0;					\
-			}							\
-			__pthread_cleanup_pop_imp(execute);			\
-		}
-
-int		pthread_condattr_destroy(pthread_condattr_t *) __nonnull(1);
-int		pthread_condattr_getclock(const pthread_condattr_t *,
-			clockid_t *) __nonnull_all;
-int		pthread_condattr_getpshared(const pthread_condattr_t *, int *)
-			__nonnull_all;
-int		pthread_condattr_init(pthread_condattr_t *) __nonnull(1);
-int		pthread_condattr_setclock(pthread_condattr_t *, clockid_t)
-			__nonnull(1);
-int		pthread_condattr_setpshared(pthread_condattr_t *, int)
-			__nonnull(1);
-int		pthread_cond_broadcast(pthread_cond_t *)
-			__nonnull(1);
-int		pthread_cond_destroy(pthread_cond_t *)
-			__nonnull(1);
-int		pthread_cond_init(pthread_cond_t *,
-			const pthread_condattr_t *) __nonnull(1);
-int		pthread_cond_signal(pthread_cond_t *) __nonnull(1);
-int		pthread_cond_timedwait(pthread_cond_t *,
-			pthread_mutex_t *__mutex, const struct timespec *)
-			__nonnull_all __requires_exclusive(*__mutex);
-int		pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *__mutex)
-			__nonnull_all __requires_exclusive(*__mutex);
-int		pthread_create(pthread_t *, const pthread_attr_t *,
-			void *(*) (void *), void *) __nonnull(1) __nonnull(3);
-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 *) __nonnull(2);
-int		pthread_join(pthread_t, void **);
-int		pthread_key_create(pthread_key_t *,
-			void (*) (void *)) __nonnull(1);
-int		pthread_key_delete(pthread_key_t);
-int		pthread_mutexattr_init(pthread_mutexattr_t *) __nonnull(1);
-int		pthread_mutexattr_destroy(pthread_mutexattr_t *) __nonnull(1);
-int		pthread_mutexattr_getpshared(const pthread_mutexattr_t *,
-			int *) __nonnull_all;
-int		pthread_mutexattr_gettype(pthread_mutexattr_t *, int *)
-			__nonnull_all;
-int		pthread_mutexattr_settype(pthread_mutexattr_t *, int)
-			__nonnull(1);
-int		pthread_mutexattr_setpshared(pthread_mutexattr_t *, int)
-			__nonnull(1);
-int		pthread_mutex_consistent(pthread_mutex_t *__mutex)
-			__nonnull(1) __requires_exclusive(*__mutex);
-int		pthread_mutex_destroy(pthread_mutex_t *__mutex)
-			__nonnull(1) __requires_unlocked(*__mutex);
-int		pthread_mutex_init(pthread_mutex_t *__mutex,
-			const pthread_mutexattr_t *)
-			__nonnull(1) __requires_unlocked(*__mutex);
-int		pthread_mutex_lock(pthread_mutex_t *__mutex)
-			__nonnull(1) __locks_exclusive(*__mutex);
-int		pthread_mutex_trylock(pthread_mutex_t *__mutex)
-			__nonnull(1) __trylocks_exclusive(0, *__mutex);
-int		pthread_mutex_timedlock(pthread_mutex_t *__mutex,
-			const struct timespec *)
-			__nonnull_all __trylocks_exclusive(0, *__mutex);
-int		pthread_mutex_unlock(pthread_mutex_t *__mutex)
-			__nonnull(1) __unlocks(*__mutex);
-int		pthread_once(pthread_once_t *, void (*) (void)) __nonnull_all;
-int		pthread_rwlock_destroy(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __requires_unlocked(*__rwlock);
-int		pthread_rwlock_init(pthread_rwlock_t *__rwlock,
-			const pthread_rwlockattr_t *)
-			__nonnull(1) __requires_unlocked(*__rwlock);
-int		pthread_rwlock_rdlock(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __locks_shared(*__rwlock);
-int		pthread_rwlock_timedrdlock(pthread_rwlock_t *__rwlock,
-			const struct timespec *)
-			__nonnull_all __trylocks_shared(0, *__rwlock);
-int		pthread_rwlock_timedwrlock(pthread_rwlock_t *__rwlock,
-			const struct timespec *)
-			__nonnull_all __trylocks_exclusive(0, *__rwlock);
-int		pthread_rwlock_tryrdlock(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __trylocks_shared(0, *__rwlock);
-int		pthread_rwlock_trywrlock(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __trylocks_exclusive(0, *__rwlock);
-int		pthread_rwlock_unlock(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __unlocks(*__rwlock);
-int		pthread_rwlock_wrlock(pthread_rwlock_t *__rwlock)
-			__nonnull(1) __locks_exclusive(*__rwlock);
-int		pthread_rwlockattr_destroy(pthread_rwlockattr_t *)
-			__nonnull(1);
-int		pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *,
-			int *);
-int		pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *,
-			int *) __nonnull_all;
-int		pthread_rwlockattr_init(pthread_rwlockattr_t *)
-			__nonnull(1);
-int		pthread_rwlockattr_setkind_np(pthread_rwlockattr_t *, int);
-int		pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int)
-			__nonnull(1);
-pthread_t	pthread_self(void);
-int		pthread_setspecific(pthread_key_t, const void *);
-
-int		pthread_spin_init(pthread_spinlock_t *__spin, int)
-			__requires_unlocked(*__spin);
-int		pthread_spin_destroy(pthread_spinlock_t *__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_cancel(pthread_t);
-int		pthread_setcancelstate(int, int *);
-int		pthread_setcanceltype(int, int *);
-void		pthread_testcancel(void);
+int	pthread_atfork(void (*)(void), void (*)(void), void (*)(void));
+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 *, size_t *);
+int	pthread_attr_getstackaddr(const pthread_attr_t *, void **);
+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)
+		__nonnull(1);
+int	pthread_attr_setstackaddr(pthread_attr_t *, void *);
+int	pthread_attr_setdetachstate(pthread_attr_t * _Nonnull, int);
+int	pthread_barrier_destroy(pthread_barrier_t *);
+int	pthread_barrier_init(pthread_barrier_t *,
+		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 * _Nonnull);
+int	pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);
+
+#define	pthread_cleanup_push(cleanup_routine, cleanup_arg)		\
+	{								\
+		struct _pthread_cleanup_info __cleanup_info__;		\
+		__pthread_cleanup_push_imp(cleanup_routine, cleanup_arg,\
+			&__cleanup_info__);				\
+		{
+
+#define	pthread_cleanup_pop(execute)					\
+			(void)0;					\
+		}							\
+		__pthread_cleanup_pop_imp(execute);			\
+	}
+
+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 * _Nonnull);
+int	pthread_cond_timedwait(pthread_cond_t * _Nonnull,
+		pthread_mutex_t *__mutex _Nonnull,
+		const struct timespec * _Nonnull)
+		__nonnull_all __requires_exclusive(*__mutex);
+int	pthread_cond_wait(pthread_cond_t * _Nonnull,
+		pthread_mutex_t * _Nonnull __mutex)
+		__nonnull_all __requires_exclusive(*__mutex);
+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 * _Nonnull);
+int	pthread_join(pthread_t, 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 * _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 * _Nonnull __mutex,
+		const pthread_mutexattr_t * _Nonnull)
+		__requires_unlocked(*__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 * _Nonnull, void (* _Nonnull) (void));
+int	pthread_rwlock_destroy(pthread_rwlock_t * _Nonnull __rwlock)
+		__requires_unlocked(*__rwlock);
+int	pthread_rwlock_init(pthread_rwlock_t * _Nonnull __rwlock,
+		const pthread_rwlockattr_t *)
+		__requires_unlocked(*__rwlock);
+int	pthread_rwlock_rdlock(pthread_rwlock_t * _Nonnull __rwlock)
+		__nonnull(1) __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 * _Nonnull __rwlock)
+		__locks_exclusive(*__rwlock);
+int	pthread_rwlockattr_destroy(pthread_rwlockattr_t * _Nonnull);
+int	pthread_rwlockattr_getkind_np(const pthread_rwlockattr_t *,
+		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 *, 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)
+		__requires_unlocked(*__spin);
+int	pthread_spin_destroy(pthread_spinlock_t *__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_cancel(pthread_t);
+int	pthread_setcancelstate(int, int *);
+int	pthread_setcanceltype(int, int *);
+void	pthread_testcancel(void);
 
 #if __BSD_VISIBLE
-int		pthread_getprio(pthread_t);
-int		pthread_setprio(pthread_t, int);
-void		pthread_yield(void);
+int	pthread_getprio(pthread_t);
+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_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_attr_getinheritsched(const pthread_attr_t *, int *);
-int		pthread_attr_getschedparam(const pthread_attr_t *,
-			struct sched_param *) __nonnull_all;
-int		pthread_attr_getschedpolicy(const pthread_attr_t *, int *)
-			__nonnull_all;
-int		pthread_attr_getscope(const pthread_attr_t *, int *)
-			__nonnull_all;
-int		pthread_attr_setinheritsched(pthread_attr_t *, int);
-int		pthread_attr_setschedparam(pthread_attr_t *,
-			const struct sched_param *) __nonnull(1) __nonnull(2);
-int		pthread_attr_setschedpolicy(pthread_attr_t *, int) __nonnull(1);
-int		pthread_attr_setscope(pthread_attr_t *, int) __nonnull(1);
-int		pthread_getschedparam(pthread_t pthread, int *,
-			struct sched_param *) __nonnull(2) __nonnull(3);
-int		pthread_setschedparam(pthread_t, int,
-			const struct sched_param *) __nonnull(3);
+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 * _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 * _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 * _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 * _Nonnull);
 #if __XSI_VISIBLE
-int		pthread_getconcurrency(void);
-int		pthread_setconcurrency(int);
+int	pthread_getconcurrency(void);
+int	pthread_setconcurrency(int);
 #endif
 
-void		__pthread_cleanup_push_imp(void (*)(void *), void *,
-			struct _pthread_cleanup_info *);
-void		__pthread_cleanup_pop_imp(int);
+void	__pthread_cleanup_push_imp(void (*)(void *), void *,
+		struct _pthread_cleanup_info *);
+void	__pthread_cleanup_pop_imp(int);
 __END_DECLS
 
 #endif
Index: include/signal.h
===================================================================
--- include/signal.h
+++ include/signal.h
@@ -82,10 +82,11 @@
 int	sigemptyset(sigset_t *);
 int	sigfillset(sigset_t *);
 int	sigismember(const sigset_t *, int);
-int	sigpending(sigset_t *) __nonnull(1);
+int	sigpending(sigset_t * _Nonnull);
 int	sigprocmask(int, const sigset_t * __restrict, sigset_t * __restrict);
-int	sigsuspend(const sigset_t *) __nonnull(1);
-int	sigwait(const sigset_t * __restrict, int * __restrict) __nonnull_all;
+int	sigsuspend(const sigset_t * _Nonnull) __nonnull(1);
+int	sigwait(const sigset_t * _Nonnull __restrict,
+	    int * _Nonnull __restrict);
 #endif
 
 #if __POSIX_VISIBLE >= 199506 || __XSI_VISIBLE >= 600
@@ -104,7 +105,7 @@
 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
 
Index: include/stdio.h
===================================================================
--- include/stdio.h
+++ include/stdio.h
@@ -123,10 +123,10 @@
 
 	/* 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 +390,10 @@
  * 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)
 
Index: include/stdlib.h
===================================================================
--- include/stdlib.h
+++ include/stdlib.h
@@ -81,12 +81,12 @@
 
 _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 +100,7 @@
 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 +256,9 @@
 __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 +282,13 @@
 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 *));
Index: sys/sys/cdefs.h
===================================================================
--- sys/sys/cdefs.h
+++ sys/sys/cdefs.h
@@ -804,6 +804,14 @@
 #endif
 
 /*
+ * Nullability qualifiers: currently only supported by Clang.
+ */
+#if !(defined(__clang__) && __has_feature(nullability))
+#define	_Nonnull
+#define	_Nullable
+#endif
+
+/*
  * Type Safety Checking
  *
  * Clang provides additional attributes to enable checking type safety
Index: sys/sys/systm.h
===================================================================
--- sys/sys/systm.h
+++ sys/sys/systm.h
@@ -227,12 +227,12 @@
 int	vsnrprintf(char *, size_t, int, const char *, __va_list) __printflike(4, 0);
 int	vsprintf(char *buf, const char *, __va_list) __printflike(2, 0);
 int	ttyprintf(struct tty *, const char *, ...) __printflike(2, 3);
-int	sscanf(const char *, char const *, ...) __nonnull(1) __nonnull(2) __scanflike(2, 3);
-int	vsscanf(const char *, char const *, __va_list) __nonnull(1) __nonnull(2) __scanflike(2, 0);
-long	strtol(const char *, char **, int) __nonnull(1);
-u_long	strtoul(const char *, char **, int) __nonnull(1);
-quad_t	strtoq(const char *, char **, int) __nonnull(1);
-u_quad_t strtouq(const char *, char **, int) __nonnull(1);
+int	sscanf(const char *, char const * _Nonnull, ...) __scanflike(2, 3);
+int	vsscanf(const char * _Nonnull, char const * _Nonnull, __va_list)  __scanflike(2, 0);
+long	strtol(const char *, char **, int);
+u_long	strtoul(const char *, char **, int);
+quad_t	strtoq(const char *, char **, int);
+u_quad_t strtouq(const char *, char **, int);
 void	tprintf(struct proc *p, int pri, const char *, ...) __printflike(3, 4);
 void	vtprintf(struct proc *, int, const char *, __va_list) __printflike(3, 0);
 void	hexdump(const void *ptr, int length, const char *hdr, int flags);
@@ -243,27 +243,27 @@
 #define	HD_OMIT_CHARS	(1 << 18)
 
 #define ovbcopy(f, t, l) bcopy((f), (t), (l))
-void	bcopy(const void *from, void *to, size_t len) __nonnull(1) __nonnull(2);
-void	bzero(void *buf, size_t len) __nonnull(1);
-void	explicit_bzero(void *, size_t) __nonnull(1);
-
-void	*memcpy(void *to, const void *from, size_t len) __nonnull(1) __nonnull(2);
-void	*memmove(void *dest, const void *src, size_t n) __nonnull(1) __nonnull(2);
-
-int	copystr(const void * __restrict kfaddr, void * __restrict kdaddr,
-	    size_t len, size_t * __restrict lencopied)
-	    __nonnull(1) __nonnull(2);
-int	copyinstr(const void * __restrict udaddr, void * __restrict kaddr,
-	    size_t len, size_t * __restrict lencopied)
-	    __nonnull(1) __nonnull(2);
-int	copyin(const void * __restrict udaddr, void * __restrict kaddr,
-	    size_t len) __nonnull(1) __nonnull(2);
-int	copyin_nofault(const void * __restrict udaddr, void * __restrict kaddr,
-	    size_t len) __nonnull(1) __nonnull(2);
-int	copyout(const void * __restrict kaddr, void * __restrict udaddr,
-	    size_t len) __nonnull(1) __nonnull(2);
-int	copyout_nofault(const void * __restrict kaddr, void * __restrict udaddr,
-	    size_t len) __nonnull(1) __nonnull(2);
+void	bcopy(const void *from _Nonnull, void * _Nonnull to, size_t len);
+void	bzero(void * _Nonnull buf, size_t len);
+void	explicit_bzero(void * _Nonnull, size_t);
+
+void	*memcpy(void * _Nonnull to, const void * _Nonnull from, size_t len);
+void	*memmove(void * _Nonnull dest, const void * _Nonnull src, size_t n);
+
+int	copystr(const void * _Nonnull __restrict kfaddr,
+	    void * _Nonnull __restrict kdaddr, size_t len,
+	    size_t * __restrict lencopied);
+int	copyinstr(const void * _Nonnull __restrict udaddr,
+	    void * _Nonnull __restrict kaddr, size_t len,
+	    size_t * __restrict lencopied);
+int	copyin(const void * _Nonnull __restrict udaddr,
+	    void * _Nonnull __restrict kaddr, size_t len);
+int	copyin_nofault(const void * _Nonnull __restrict udaddr,
+	    void * _Nonnull __restrict kaddr, size_t len);
+int	copyout(const void * _Nonnull __restrict kaddr,
+	    void * _Nonnull __restrict udaddr, size_t len));
+int	copyout_nofault(const void * _Nonnull __restrict kaddr,
+	    void * _Nonnull __restrict udaddr, size_t len);
 
 int	fubyte(volatile const void *base);
 long	fuword(volatile const void *base);
@@ -374,16 +374,16 @@
  * Common `proc' functions are declared here so that proc.h can be included
  * less often.
  */
-int	_sleep(void *chan, struct lock_object *lock, int pri, const char *wmesg,
-	   sbintime_t sbt, sbintime_t pr, int flags) __nonnull(1);
+int	_sleep(void * _Nonnull chan, struct lock_object *lock, int pri,
+	   const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
 #define	msleep(chan, mtx, pri, wmesg, timo)				\
 	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg),		\
 	    tick_sbt * (timo), 0, C_HARDCLOCK)
 #define	msleep_sbt(chan, mtx, pri, wmesg, bt, pr, flags)		\
 	_sleep((chan), &(mtx)->lock_object, (pri), (wmesg), (bt), (pr),	\
 	    (flags))
-int	msleep_spin_sbt(void *chan, struct mtx *mtx, const char *wmesg,
-	    sbintime_t sbt, sbintime_t pr, int flags) __nonnull(1);
+int	msleep_spin_sbt(void * _Nonnull chan, struct mtx *mtx,
+	    const char *wmesg, sbintime_t sbt, sbintime_t pr, int flags);
 #define	msleep_spin(chan, mtx, wmesg, timo)				\
 	msleep_spin_sbt((chan), (mtx), (wmesg), tick_sbt * (timo),	\
 	    0, C_HARDCLOCK)
@@ -396,8 +396,8 @@
 	    0, C_HARDCLOCK)
 #define	tsleep_sbt(chan, pri, wmesg, bt, pr, flags)			\
 	_sleep((chan), NULL, (pri), (wmesg), (bt), (pr), (flags))
-void	wakeup(void *chan) __nonnull(1);
-void	wakeup_one(void *chan) __nonnull(1);
+void	wakeup(void * _Nonnull chan);
+void	wakeup_one(void * _Nonnull chan);
 
 /*
  * Common `struct cdev *' stuff are declared here to avoid #include poisoning