Index: sys/arm/samsung/exynos/chrome_kb.c
===================================================================
--- sys/arm/samsung/exynos/chrome_kb.c
+++ sys/arm/samsung/exynos/chrome_kb.c
@@ -82,7 +82,7 @@
  */
 #define	CKB_CTX_LOCK_ASSERT()			 	\
 	do {						\
-		if (!kdb_active && panicstr == NULL)	\
+		if (!kdb_active && !KERNEL_PANICKED())	\
 			mtx_assert(&Giant, MA_OWNED);	\
 	} while (0)
 #else
Index: sys/arm/versatile/pl050.c
===================================================================
--- sys/arm/versatile/pl050.c
+++ sys/arm/versatile/pl050.c
@@ -76,7 +76,7 @@
  */
 #define	KMI_CTX_LOCK_ASSERT()			 	\
 	do {						\
-		if (!kdb_active && panicstr == NULL)	\
+		if (!kdb_active && !KERNEL_PANICKED())	\
 			mtx_assert(&Giant, MA_OWNED);	\
 	} while (0)
 #else
Index: sys/cddl/compat/opensolaris/sys/mutex.h
===================================================================
--- sys/cddl/compat/opensolaris/sys/mutex.h
+++ sys/cddl/compat/opensolaris/sys/mutex.h
@@ -42,7 +42,7 @@
 } kmutex_type_t;
 
 #define	MUTEX_HELD(x)		(mutex_owned(x))
-#define	MUTEX_NOT_HELD(x)	(!mutex_owned(x) || panicstr)
+#define	MUTEX_NOT_HELD(x)	(!mutex_owned(x) || KERNEL_PANICKED())
 
 typedef struct sx	kmutex_t;
 
Index: sys/dev/acpica/acpi.c
===================================================================
--- sys/dev/acpica/acpi.c
+++ sys/dev/acpica/acpi.c
@@ -2170,7 +2170,7 @@
 	} else if (status != AE_NOT_EXIST)
 	    device_printf(sc->acpi_dev, "reset failed - %s\n",
 		AcpiFormatException(status));
-    } else if (sc->acpi_do_disable && panicstr == NULL) {
+    } else if (sc->acpi_do_disable && !KERNEL_PANICKED()) {
 	/*
 	 * Only disable ACPI if the user requested.  On some systems, writing
 	 * the disable value to SMI_CMD hangs the system.
Index: sys/dev/drm2/drm_fb_helper.c
===================================================================
--- sys/dev/drm2/drm_fb_helper.c
+++ sys/dev/drm2/drm_fb_helper.c
@@ -74,7 +74,7 @@
 
 	sc = (struct vt_kms_softc *)arg;
 
-	if (!kdb_active && panicstr == NULL)
+	if (!kdb_active && !KERNEL_PANICKED())
 		taskqueue_enqueue(taskqueue_thread, &sc->fb_mode_task);
 	else
 		drm_fb_helper_restore_fbdev_mode(sc->fb_helper);
Index: sys/dev/syscons/syscons.c
===================================================================
--- sys/dev/syscons/syscons.c
+++ sys/dev/syscons/syscons.c
@@ -2131,7 +2131,7 @@
     if (suspend_in_progress || scp->sc->font_loading_in_progress)
 	return;
 
-    if (kdb_active || panicstr || shutdown_in_progress) {
+    if (kdb_active || KERNEL_PANICKED() || shutdown_in_progress) {
 	sc_touch_scrn_saver();
     } else if (scp != scp->sc->cur_scp) {
 	return;
@@ -2196,7 +2196,7 @@
     }
 
     /* should we stop the screen saver? */
-    if (kdb_active || panicstr || shutdown_in_progress)
+    if (kdb_active || KERNEL_PANICKED() || shutdown_in_progress)
 	sc_touch_scrn_saver();
     if (run_scrn_saver) {
 	if (time_uptime > sc->scrn_time_stamp + scrn_blank_time)
Index: sys/dev/vt/vt_core.c
===================================================================
--- sys/dev/vt/vt_core.c
+++ sys/dev/vt/vt_core.c
@@ -1261,7 +1261,7 @@
 	/* Check if the cursor should be displayed or not. */
 	if ((vd->vd_flags & VDF_MOUSECURSOR) && /* Mouse support enabled. */
 	    !(vw->vw_flags & VWF_MOUSE_HIDE) && /* Cursor displayed.      */
-	    !kdb_active && panicstr == NULL) {  /* DDB inactive.          */
+	    !kdb_active && !KERNEL_PANICKED()) { /* DDB inactive.         */
 		vd->vd_mshown = 1;
 	} else {
 		vd->vd_mshown = 0;
@@ -1355,7 +1355,7 @@
 	struct vt_window *vw = tm->tm_softc;
 	struct vt_device *vd = vw->vw_device;
 
-	if (kdb_active || panicstr != NULL) {
+	if (kdb_active || KERNEL_PANICKED()) {
 		/* Switch to the debugger. */
 		if (vd->vd_curwindow != vw) {
 			vd->vd_curwindow = vw;
Index: sys/dev/xen/console/xen_console.c
===================================================================
--- sys/dev/xen/console/xen_console.c
+++ sys/dev/xen/console/xen_console.c
@@ -198,7 +198,7 @@
 static inline void xencons_lock(struct xencons_priv *cons)
 {
 
-	if (panicstr == NULL)
+	if (!KERNEL_PANICKED())
 		mtx_lock_spin(&cons->mtx);
 
 }
@@ -206,7 +206,7 @@
 static inline void xencons_unlock(struct xencons_priv *cons)
 {
 
-	if (panicstr == NULL)
+	if (!KERNEL_PANICKED())
 		mtx_unlock_spin(&cons->mtx);
 }
 
Index: sys/geom/journal/g_journal.c
===================================================================
--- sys/geom/journal/g_journal.c
+++ sys/geom/journal/g_journal.c
@@ -2652,7 +2652,7 @@
 	struct g_class *mp;
 	struct g_geom *gp, *gp2;
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 	mp = arg;
 	g_topology_lock();
Index: sys/geom/mirror/g_mirror.c
===================================================================
--- sys/geom/mirror/g_mirror.c
+++ sys/geom/mirror/g_mirror.c
@@ -3442,7 +3442,7 @@
 	struct g_mirror_softc *sc;
 	int error;
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 
 	mp = arg;
Index: sys/kern/kern_ktr.c
===================================================================
--- sys/kern/kern_ktr.c
+++ sys/kern/kern_ktr.c
@@ -325,7 +325,7 @@
 #endif
 	int cpu;
 
-	if (panicstr || kdb_active)
+	if (KERNEL_PANICKED() || kdb_active)
 		return;
 	if ((ktr_mask & mask) == 0 || ktr_buf == NULL)
 		return;
Index: sys/kern/kern_lock.c
===================================================================
--- sys/kern/kern_lock.c
+++ sys/kern/kern_lock.c
@@ -558,7 +558,7 @@
 	int contested = 0;
 #endif
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		goto out;
 
 	tid = (uintptr_t)curthread;
@@ -685,7 +685,7 @@
 	int contested = 0;
 #endif
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		goto out;
 
 	tid = (uintptr_t)curthread;
@@ -855,7 +855,7 @@
 	int wakeup_swapper = 0;
 	int op;
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		goto out;
 
 	tid = (uintptr_t)curthread;
@@ -913,7 +913,7 @@
 	u_int op;
 	bool locked;
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		return (0);
 
 	op = flags & LK_TYPE_MASK;
@@ -975,7 +975,7 @@
 {
 	int wakeup_swapper = 0;
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		goto out;
 
 	wakeup_swapper = wakeupshlk(lk, file, line);
@@ -994,7 +994,7 @@
 	u_int realexslp;
 	int queue;
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		goto out;
 
 	tid = (uintptr_t)curthread;
@@ -1097,7 +1097,7 @@
 	const char *file;
 	int line;
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		return (0);
 
 	file = __FILE__;
@@ -1143,7 +1143,7 @@
 	int contested = 0;
 #endif
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return (0);
 
 	error = 0;
@@ -1549,7 +1549,7 @@
 {
 	int slocked = 0;
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 	switch (what) {
 	case KA_SLOCKED:
Index: sys/kern/kern_mutex.c
===================================================================
--- sys/kern/kern_mutex.c
+++ sys/kern/kern_mutex.c
@@ -1047,7 +1047,7 @@
 {
 	const struct mtx *m;
 
-	if (panicstr != NULL || dumping || SCHEDULER_STOPPED())
+	if (KERNEL_PANICKED() || dumping || SCHEDULER_STOPPED())
 		return;
 
 	m = mtxlock2mtx(c);
@@ -1205,7 +1205,7 @@
 	struct thread *td;
 
 	ldap->spin_cnt++;
-	if (ldap->spin_cnt < 60000000 || kdb_active || panicstr != NULL)
+	if (ldap->spin_cnt < 60000000 || kdb_active || KERNEL_PANICKED())
 		DELAY(1);
 	else {
 		td = mtx_owner(m);
Index: sys/kern/kern_rmlock.c
===================================================================
--- sys/kern/kern_rmlock.c
+++ sys/kern/kern_rmlock.c
@@ -742,7 +742,7 @@
 {
 	int count;
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 	switch (what) {
 	case RA_LOCKED:
Index: sys/kern/kern_rwlock.c
===================================================================
--- sys/kern/kern_rwlock.c
+++ sys/kern/kern_rwlock.c
@@ -1439,7 +1439,7 @@
 {
 	const struct rwlock *rw;
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 
 	rw = rwlock2rw(c);
Index: sys/kern/kern_shutdown.c
===================================================================
--- sys/kern/kern_shutdown.c
+++ sys/kern/kern_shutdown.c
@@ -198,7 +198,8 @@
 
 /*
  * Variable panicstr contains argument to first call to panic; used as flag
- * to indicate that the kernel has already called panic.
+ * to indicate that the kernel has panicked.  Check with the macro
+ * KERNEL_PANICKED() rather than accessing it directly.
  */
 const char *panicstr;
 
@@ -735,7 +736,7 @@
 	 * If we are suppressing secondary panics, log the warning but do not
 	 * re-enter panic/kdb.
 	 */
-	if (panicstr != NULL && kassert_suppress_in_panic) {
+	if (KERNEL_PANICKED() && kassert_suppress_in_panic) {
 		if (kassert_do_log) {
 			printf("KASSERT failed: %s\n", buf);
 #ifdef KDB
@@ -933,7 +934,7 @@
 	struct thread *td;
 	int error;
 
-	if (panicstr)
+	if (KERNEL_PANICKED())
 		return;
 
 	td = (struct thread *)arg;
@@ -1561,7 +1562,7 @@
 	dstsize = sizeof(kdh->versionstring);
 	if (strlcpy(kdh->versionstring, version, dstsize) >= dstsize)
 		kdh->versionstring[dstsize - 2] = '\n';
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		strlcpy(kdh->panicstring, panicstr, sizeof(kdh->panicstring));
 	if (di->kdcomp != NULL)
 		kdh->compression = di->kdcomp->kdc_format;
Index: sys/kern/kern_switch.c
===================================================================
--- sys/kern/kern_switch.c
+++ sys/kern/kern_switch.c
@@ -181,7 +181,7 @@
 
 	td = sched_choose();
 
-	if (__predict_false(panicstr != NULL))
+	if (KERNEL_PANICKED())
 		return (choosethread_panic(td));
 
 	TD_SET_RUNNING(td);
Index: sys/kern/kern_sx.c
===================================================================
--- sys/kern/kern_sx.c
+++ sys/kern/kern_sx.c
@@ -1416,7 +1416,7 @@
 	int slocked = 0;
 #endif
 
-	if (panicstr != NULL)
+	if (KERNEL_PANICKED())
 		return;
 	switch (what) {
 	case SA_SLOCKED:
Index: sys/kern/kern_synch.c
===================================================================
--- sys/kern/kern_synch.c
+++ sys/kern/kern_synch.c
@@ -393,7 +393,7 @@
 	if (!TD_ON_LOCK(td) && !TD_IS_RUNNING(td))
 		mtx_assert(&Giant, MA_NOTOWNED);
 #endif
-	KASSERT(td->td_critnest == 1 || panicstr,
+	KASSERT(td->td_critnest == 1 || KERNEL_PANICKED(),
 	    ("mi_switch: switch in a critical section"));
 	KASSERT((flags & (SW_INVOL | SW_VOL)) != 0,
 	    ("mi_switch: switch must be voluntary or involuntary"));
Index: sys/kern/sched_4bsd.c
===================================================================
--- sys/kern/sched_4bsd.c
+++ sys/kern/sched_4bsd.c
@@ -324,7 +324,7 @@
 	 * The new thread should not preempt the current thread if any of the
 	 * following conditions are true:
 	 *
-	 *  - The kernel is in the throes of crashing (panicstr).
+	 *  - The kernel is in the throes of crashing (KERNEL_PANICKED()).
 	 *  - The current thread has a higher (numerically lower) or
 	 *    equivalent priority.  Note that this prevents curthread from
 	 *    trying to preempt to itself.
@@ -348,7 +348,7 @@
 			("maybe_preempt: trying to run inhibited thread"));
 	pri = td->td_priority;
 	cpri = ctd->td_priority;
-	if (panicstr != NULL || pri >= cpri /* || dumping */ ||
+	if (KERNEL_PANICKED() || pri >= cpri /* || dumping */ ||
 	    TD_IS_INHIBITED(ctd))
 		return (0);
 #ifndef FULL_PREEMPTION
@@ -1120,7 +1120,7 @@
 	if ((!forward_wakeup_enabled) ||
 	     (forward_wakeup_use_mask == 0 && forward_wakeup_use_loop == 0))
 		return (0);
-	if (!smp_started || panicstr)
+	if (!smp_started || KERNEL_PANICKED())
 		return (0);
 
 	forward_wakeups_requested++;
Index: sys/kern/sched_ule.c
===================================================================
--- sys/kern/sched_ule.c
+++ sys/kern/sched_ule.c
@@ -2496,7 +2496,7 @@
 	cpri = ctd->td_priority;
 	if (pri < cpri)
 		ctd->td_flags |= TDF_NEEDRESCHED;
-	if (panicstr != NULL || pri >= cpri || cold || TD_IS_INHIBITED(ctd))
+	if (KERNEL_PANICKED() || pri >= cpri || cold || TD_IS_INHIBITED(ctd))
 		return;
 	if (!sched_shouldpreempt(pri, cpri, 0))
 		return;
Index: sys/kern/subr_prf.c
===================================================================
--- sys/kern/subr_prf.c
+++ sys/kern/subr_prf.c
@@ -428,7 +428,7 @@
 
 	retval = _vprintf(-1, TOCONS | TOLOG, fmt, ap);
 
-	if (!panicstr)
+	if (!KERNEL_PANICKED())
 		msgbuftrigger = 1;
 
 	return (retval);
@@ -442,7 +442,7 @@
 		msglogstr(bufr, pri, /*filter_cr*/1);
 
 	if (flags & TOCONS) {
-		if ((panicstr == NULL) && (constty != NULL))
+		if (!KERNEL_PANICKED() && (constty != NULL))
 			msgbuf_addstr(&consmsgbuf, -1,
 			    bufr, /*filter_cr*/ 0);
 
@@ -511,7 +511,7 @@
 		return;
 	}
 
-	if ((flags & TOTTY) && tp != NULL && panicstr == NULL)
+	if ((flags & TOTTY) && tp != NULL && !KERNEL_PANICKED())
 		tty_putchar(tp, c);
 
 	if ((flags & (TOCONS | TOLOG)) && c != '\0')
Index: sys/kern/subr_smp.c
===================================================================
--- sys/kern/subr_smp.c
+++ sys/kern/subr_smp.c
@@ -182,7 +182,7 @@
 
 	CTR1(KTR_SMP, "forward_signal(%p)", td->td_proc);
 
-	if (!smp_started || cold || panicstr)
+	if (!smp_started || cold || KERNEL_PANICKED())
 		return;
 	if (!forward_signal_enabled)
 		return;
Index: sys/kern/subr_witness.c
===================================================================
--- sys/kern/subr_witness.c
+++ sys/kern/subr_witness.c
@@ -894,7 +894,7 @@
 	 * it to the pending_locks list.  If it is not too early, then enroll
 	 * the lock now.
 	 */
-	if (witness_watch < 1 || panicstr != NULL ||
+	if (witness_watch < 1 || KERNEL_PANICKED() ||
 	    (lock->lo_flags & LO_WITNESS) == 0)
 		lock->lo_witness = NULL;
 	else if (witness_cold) {
@@ -1072,7 +1072,7 @@
 witness_defineorder(struct lock_object *lock1, struct lock_object *lock2)
 {
 
-	if (witness_watch == -1 || panicstr != NULL)
+	if (witness_watch == -1 || KERNEL_PANICKED())
 		return (0);
 
 	/* Require locks that witness knows about. */
@@ -1113,7 +1113,7 @@
 	int i, j;
 
 	if (witness_cold || witness_watch < 1 || lock->lo_witness == NULL ||
-	    panicstr != NULL)
+	    KERNEL_PANICKED())
 		return;
 
 	w = lock->lo_witness;
@@ -1457,7 +1457,7 @@
 	struct thread *td;
 
 	if (witness_cold || witness_watch == -1 || lock->lo_witness == NULL ||
-	    panicstr != NULL)
+	    KERNEL_PANICKED())
 		return;
 	w = lock->lo_witness;
 	td = curthread;
@@ -1514,7 +1514,7 @@
 	struct lock_class *class;
 
 	KASSERT(witness_cold == 0, ("%s: witness_cold", __func__));
-	if (lock->lo_witness == NULL || witness_watch == -1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch == -1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if (witness_watch) {
@@ -1560,7 +1560,7 @@
 	struct lock_class *class;
 
 	KASSERT(witness_cold == 0, ("%s: witness_cold", __func__));
-	if (lock->lo_witness == NULL || witness_watch == -1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch == -1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if (witness_watch) {
@@ -1608,7 +1608,7 @@
 	register_t s;
 	int i, j;
 
-	if (witness_cold || lock->lo_witness == NULL || panicstr != NULL)
+	if (witness_cold || lock->lo_witness == NULL || KERNEL_PANICKED())
 		return;
 	td = curthread;
 	class = LOCK_CLASS(lock);
@@ -1714,7 +1714,7 @@
 	int i, n;
 
 	lle = td->td_sleeplocks;
-	if (lle == NULL || panicstr != NULL)
+	if (lle == NULL || KERNEL_PANICKED())
 		return;
 	if (lle->ll_count != 0) {
 		for (n = 0; lle != NULL; lle = lle->ll_next)
@@ -1749,7 +1749,7 @@
 	va_list ap;
 	int i, n;
 
-	if (witness_cold || witness_watch < 1 || panicstr != NULL)
+	if (witness_cold || witness_watch < 1 || KERNEL_PANICKED())
 		return (0);
 	n = 0;
 	td = curthread;
@@ -1841,7 +1841,7 @@
 
 	MPASS(description != NULL);
 
-	if (witness_watch == -1 || panicstr != NULL)
+	if (witness_watch == -1 || KERNEL_PANICKED())
 		return (NULL);
 	if ((lock_class->lc_flags & LC_SPINLOCK)) {
 		if (witness_skipspin)
@@ -2317,7 +2317,7 @@
 	if (SCHEDULER_STOPPED())
 		return;
 	KASSERT(witness_cold == 0, ("%s: witness_cold", __func__));
-	if (lock->lo_witness == NULL || witness_watch == -1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch == -1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if (class->lc_flags & LC_SLEEPLOCK)
@@ -2352,7 +2352,7 @@
 	if (SCHEDULER_STOPPED())
 		return;
 	KASSERT(witness_cold == 0, ("%s: witness_cold", __func__));
-	if (lock->lo_witness == NULL || witness_watch == -1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch == -1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if (class->lc_flags & LC_SLEEPLOCK)
@@ -2382,7 +2382,7 @@
 	struct lock_instance *instance;
 	struct lock_class *class;
 
-	if (lock->lo_witness == NULL || witness_watch < 1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch < 1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if ((class->lc_flags & LC_SLEEPLOCK) != 0)
@@ -2454,7 +2454,7 @@
 	struct lock_instance *instance;
 	struct lock_class *class;
 
-	if (lock->lo_witness == NULL || witness_watch == -1 || panicstr != NULL)
+	if (lock->lo_witness == NULL || witness_watch == -1 || KERNEL_PANICKED())
 		return;
 	class = LOCK_CLASS(lock);
 	if (class->lc_flags & LC_SLEEPLOCK)
Index: sys/kern/vfs_bio.c
===================================================================
--- sys/kern/vfs_bio.c
+++ sys/kern/vfs_bio.c
@@ -1436,7 +1436,7 @@
 		/*
 		 * Unmount filesystems
 		 */
-		if (panicstr == NULL)
+		if (!KERNEL_PANICKED())
 			vfs_unmountall();
 	}
 	swapoff_all();
Index: sys/kern/vfs_subr.c
===================================================================
--- sys/kern/vfs_subr.c
+++ sys/kern/vfs_subr.c
@@ -4540,7 +4540,7 @@
  * This only exists to suppress warnings from unlocked specfs accesses.  It is
  * no longer ok to have an unlocked VFS.
  */
-#define	IGNORE_LOCK(vp) (panicstr != NULL || (vp) == NULL ||		\
+#define	IGNORE_LOCK(vp) (KERNEL_PANICKED() || (vp) == NULL ||		\
 	(vp)->v_type == VCHR ||	(vp)->v_type == VBAD)
 
 int vfs_badlock_ddb = 1;	/* Drop into debugger on violation. */
@@ -4689,7 +4689,7 @@
 	if ((bp->b_flags & B_CLUSTER) != 0)
 		return;
 
-	if (panicstr == NULL && !BUF_ISLOCKED(bp)) {
+	if (!KERNEL_PANICKED() && !BUF_ISLOCKED(bp)) {
 		if (vfs_badlock_print)
 			printf(
 			    "VOP_STRATEGY: bp is not locked but should be\n");
Index: sys/netinet/netdump/netdump_client.c
===================================================================
--- sys/netinet/netdump/netdump_client.c
+++ sys/netinet/netdump/netdump_client.c
@@ -941,7 +941,7 @@
 	if (nd_enabled == 0)
 		return (EINVAL);
 
-	if (panicstr == NULL) {
+	if (!KERNEL_PANICKED()) {
 		printf(
 		    "netdump_start: netdump may only be used after a panic\n");
 		return (EINVAL);
Index: sys/sparc64/sparc64/mp_machdep.c
===================================================================
--- sys/sparc64/sparc64/mp_machdep.c
+++ sys/sparc64/sparc64/mp_machdep.c
@@ -611,7 +611,7 @@
 		if ((ids & (IDR_BUSY | IDR_NACK)) == 0)
 			return;
 	}
-	if (kdb_active != 0 || panicstr != NULL)
+	if (kdb_active != 0 || KERNEL_PANICKED())
 		printf("%s: couldn't send IPI to module 0x%u\n",
 		    __func__, mid);
 	else
@@ -650,7 +650,7 @@
 		if ((ids & (IDR_BUSY | IDR_NACK)) == 0)
 			return;
 	}
-	if (kdb_active != 0 || panicstr != NULL)
+	if (kdb_active != 0 || KERNEL_PANICKED())
 		printf("%s: couldn't send IPI to module 0x%u\n",
 		    __func__, mid);
 	else
@@ -709,7 +709,7 @@
 		if (CPU_EMPTY(&cpus))
 			return;
 	}
-	if (kdb_active != 0 || panicstr != NULL)
+	if (kdb_active != 0 || KERNEL_PANICKED())
 		printf("%s: couldn't send IPI (cpus=%s ids=0x%lu)\n",
 		    __func__, cpusetobj_strprint(ipi_pbuf, &cpus), ids);
 	else
@@ -750,7 +750,7 @@
 		if ((ids & busynack) == 0)
 			return;
 	}
-	if (kdb_active != 0 || panicstr != NULL)
+	if (kdb_active != 0 || KERNEL_PANICKED())
 		printf("%s: couldn't send IPI to module 0x%u\n",
 		    __func__, mid);
 	else
@@ -801,7 +801,7 @@
 				    (2 * cpuid_to_mid[cpu]))) == 0)
 					CPU_CLR(cpu, &cpus);
 	}
-	if (kdb_active != 0 || panicstr != NULL)
+	if (kdb_active != 0 || KERNEL_PANICKED())
 		printf("%s: couldn't send IPI (cpus=%s ids=0x%lu)\n",
 		    __func__, cpusetobj_strprint(ipi_pbuf, &cpus), ids);
 	else
Index: sys/sys/systm.h
===================================================================
--- sys/sys/systm.h
+++ sys/sys/systm.h
@@ -89,6 +89,8 @@
 void	panic(const char *, ...) __dead2 __printflike(1, 2);
 void	vpanic(const char *, __va_list) __dead2 __printflike(1, 0);
 
+#define KERNEL_PANICKED() (__predict_false(panicstr != NULL))
+
 #if defined(WITNESS) || defined(INVARIANT_SUPPORT)
 #ifdef KASSERT_PANIC_OPTIONAL
 void	kassert_panic(const char *fmt, ...)  __printflike(1, 2);
Index: sys/x86/x86/local_apic.c
===================================================================
--- sys/x86/x86/local_apic.c
+++ sys/x86/x86/local_apic.c
@@ -2083,7 +2083,7 @@
 
 	/* Wait for an earlier IPI to finish. */
 	if (!lapic_ipi_wait(BEFORE_SPIN)) {
-		if (panicstr != NULL)
+		if (KERNEL_PANICKED())
 			return;
 		else
 			panic("APIC: Previous IPI is stuck");
Index: sys/x86/x86/mp_x86.c
===================================================================
--- sys/x86/x86/mp_x86.c
+++ sys/x86/x86/mp_x86.c
@@ -1595,7 +1595,7 @@
 	int cpu;
 
 	/* It is not necessary to signal other CPUs while in the debugger. */
-	if (kdb_active || panicstr != NULL)
+	if (kdb_active || KERNEL_PANICKED())
 		return;
 
 	/*