Index: kernel/arch/amd64/src/ddi/ddi.c
===================================================================
--- kernel/arch/amd64/src/ddi/ddi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/amd64/src/ddi/ddi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 #include <ddi/ddi.h>
 #include <arch/ddi/ddi.h>
+#include <assert.h>
 #include <proc/task.h>
 #include <adt/bitmap.h>
@@ -63,5 +64,5 @@
 	
 	if (elements > 0) {
-		ASSERT(TASK->arch.iomap.bits);
+		assert(TASK->arch.iomap.bits);
 		
 		bitmap_t iomap;
Index: kernel/arch/amd64/src/interrupt.c
===================================================================
--- kernel/arch/amd64/src/interrupt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/amd64/src/interrupt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,7 +34,7 @@
 
 #include <arch/interrupt.h>
+#include <assert.h>
 #include <print.h>
 #include <log.h>
-#include <debug.h>
 #include <panic.h>
 #include <arch/drivers/i8259.h>
@@ -175,10 +175,10 @@
 static void irq_interrupt(unsigned int n, istate_t *istate)
 {
-	ASSERT(n >= IVT_IRQBASE);
+	assert(n >= IVT_IRQBASE);
 	
 	unsigned int inum = n - IVT_IRQBASE;
 	bool ack = false;
-	ASSERT(inum < IRQ_COUNT);
-	ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
+	assert(inum < IRQ_COUNT);
+	assert((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
 	
 	irq_t *irq = irq_dispatch_and_lock(inum);
Index: kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c
===================================================================
--- kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/arm32/src/mach/beagleboardxm/beagleboardxm.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 #include <arch/exception.h>
 #include <arch/mach/beagleboardxm/beagleboardxm.h>
+#include <assert.h>
 #include <genarch/drivers/amdm37x/uart.h>
 #include <genarch/drivers/amdm37x/irc.h>
@@ -102,5 +103,5 @@
 	    (void *) km_map(AMDM37x_IRC_BASE_ADDRESS, AMDM37x_IRC_SIZE,
 	    PAGE_NOT_CACHEABLE);
-	ASSERT(beagleboard.irc_addr);
+	assert(beagleboard.irc_addr);
 	omap_irc_init(beagleboard.irc_addr);
 
Index: kernel/arch/arm32/src/mach/beaglebone/beaglebone.c
===================================================================
--- kernel/arch/arm32/src/mach/beaglebone/beaglebone.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/arm32/src/mach/beaglebone/beaglebone.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
 #include <arch/exception.h>
 #include <arch/mach/beaglebone/beaglebone.h>
+#include <assert.h>
 #include <genarch/drivers/am335x/irc.h>
 #include <genarch/drivers/am335x/uart.h>
@@ -98,8 +99,8 @@
 	    AM335x_CTRL_MODULE_SIZE, PAGE_NOT_CACHEABLE);
 
-	ASSERT(bbone.irc_addr != NULL);
-	ASSERT(bbone.cm_per_addr != NULL);
-	ASSERT(bbone.cm_dpll_addr != NULL);
-	ASSERT(bbone.ctrl_module != NULL);
+	assert(bbone.irc_addr != NULL);
+	assert(bbone.cm_per_addr != NULL);
+	assert(bbone.cm_dpll_addr != NULL);
+	assert(bbone.ctrl_module != NULL);
 
 	/* Initialize the interrupt controller */
Index: kernel/arch/arm32/src/mach/raspberrypi/raspberrypi.c
===================================================================
--- kernel/arch/arm32/src/mach/raspberrypi/raspberrypi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/arm32/src/mach/raspberrypi/raspberrypi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
 #include <arch/exception.h>
 #include <arch/mach/raspberrypi/raspberrypi.h>
+#include <assert.h>
 #include <genarch/drivers/pl011/pl011.h>
 #include <genarch/drivers/bcm2835/irc.h>
@@ -103,5 +104,5 @@
 	raspi.irc = (void *) km_map(BCM2835_IRC_ADDR, sizeof(bcm2835_irc_t),
 				    PAGE_NOT_CACHEABLE);
-	ASSERT(raspi.irc);
+	assert(raspi.irc);
 	bcm2835_irc_init(raspi.irc);
 
Index: kernel/arch/ia32/src/ddi/ddi.c
===================================================================
--- kernel/arch/ia32/src/ddi/ddi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia32/src/ddi/ddi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 #include <ddi/ddi.h>
 #include <arch/ddi/ddi.h>
+#include <assert.h>
 #include <proc/task.h>
 #include <stddef.h>
@@ -63,5 +64,5 @@
 	
 	if (elements > 0) {
-		ASSERT(TASK->arch.iomap.bits);
+		assert(TASK->arch.iomap.bits);
 		
 		bitmap_t iomap;
Index: kernel/arch/ia32/src/interrupt.c
===================================================================
--- kernel/arch/ia32/src/interrupt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia32/src/interrupt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
 
 #include <arch/interrupt.h>
+#include <assert.h>
 #include <syscall/syscall.h>
 #include <print.h>
@@ -183,10 +184,10 @@
 static void irq_interrupt(unsigned int n, istate_t *istate __attribute__((unused)))
 {
-	ASSERT(n >= IVT_IRQBASE);
+	assert(n >= IVT_IRQBASE);
 	
 	unsigned int inum = n - IVT_IRQBASE;
 	bool ack = false;
-	ASSERT(inum < IRQ_COUNT);
-	ASSERT((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
+	assert(inum < IRQ_COUNT);
+	assert((inum != IRQ_PIC_SPUR) && (inum != IRQ_PIC1));
 	
 	irq_t *irq = irq_dispatch_and_lock(inum);
Index: kernel/arch/ia32/src/smp/apic.c
===================================================================
--- kernel/arch/ia32/src/smp/apic.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia32/src/smp/apic.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
 #include <arch/smp/mps.h>
 #include <arch/boot/boot.h>
+#include <assert.h>
 #include <mm/page.h>
 #include <time/delay.h>
@@ -492,5 +493,5 @@
 	
 	/* Program Logical Destination Register. */
-	ASSERT(CPU->id < 8);
+	assert(CPU->id < 8);
 	ldr_t ldr;
 	
Index: kernel/arch/ia32/src/smp/mps.c
===================================================================
--- kernel/arch/ia32/src/smp/mps.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia32/src/smp/mps.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,8 +37,8 @@
 #include <config.h>
 #include <log.h>
-#include <debug.h>
 #include <arch/smp/mps.h>
 #include <arch/smp/apic.h>
 #include <arch/smp/smp.h>
+#include <assert.h>
 #include <func.h>
 #include <typedefs.h>
@@ -74,5 +74,5 @@
 static uint8_t mps_cpu_apic_id(size_t i)
 {
-	ASSERT(i < processor_entry_cnt);
+	assert(i < processor_entry_cnt);
 	
 	return processor_entries[i].l_apic_id;
@@ -81,5 +81,5 @@
 static bool mps_cpu_enabled(size_t i)
 {
-	ASSERT(i < processor_entry_cnt);
+	assert(i < processor_entry_cnt);
 	
 	/*
@@ -96,5 +96,5 @@
 static bool mps_cpu_bootstrap(size_t i)
 {
-	ASSERT(i < processor_entry_cnt);
+	assert(i < processor_entry_cnt);
 	
 	return (bool) ((processor_entries[i].cpu_flags & 0x02) == 0x02);
Index: kernel/arch/ia32/src/smp/smp.c
===================================================================
--- kernel/arch/ia32/src/smp/smp.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia32/src/smp/smp.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
 #include <arch/smp/ap.h>
 #include <arch/boot/boot.h>
+#include <assert.h>
 #include <genarch/acpi/acpi.h>
 #include <genarch/acpi/madt.h>
@@ -45,5 +46,4 @@
 #include <func.h>
 #include <panic.h>
-#include <debug.h>
 #include <arch/asm.h>
 #include <mm/page.h>
@@ -83,6 +83,6 @@
 static void cpu_arch_id_init(void)
 {
-	ASSERT(ops != NULL);
-	ASSERT(cpus != NULL);
+	assert(ops != NULL);
+	assert(cpus != NULL);
 	
 	for (unsigned int i = 0; i < config.cpu_count; ++i) {
@@ -102,5 +102,5 @@
 	unsigned int i;
 	
-	ASSERT(ops != NULL);
+	assert(ops != NULL);
 
 	/*
@@ -191,5 +191,5 @@
 int smp_irq_to_pin(unsigned int irq)
 {
-	ASSERT(ops != NULL);
+	assert(ops != NULL);
 	return ops->irq_to_pin(irq);
 }
Index: kernel/arch/ia64/include/arch/mm/page.h
===================================================================
--- kernel/arch/ia64/include/arch/mm/page.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/include/arch/mm/page.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,8 @@
 
 #include <arch/mm/frame.h>
+
+#ifndef __ASM__
+#include <assert.h>
+#endif
 
 #define PAGE_SIZE   FRAME_SIZE
@@ -232,5 +236,5 @@
 	uint64_t ret;
 	
-	ASSERT(i < REGION_REGISTERS);
+	assert(i < REGION_REGISTERS);
 	
 	asm volatile (
@@ -250,5 +254,5 @@
 NO_TRACE static inline void rr_write(size_t i, uint64_t v)
 {
-	ASSERT(i < REGION_REGISTERS);
+	assert(i < REGION_REGISTERS);
 	
 	asm volatile (
Index: kernel/arch/ia64/src/drivers/ski.c
===================================================================
--- kernel/arch/ia64/src/drivers/ski.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/src/drivers/ski.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
 
 #include <arch/drivers/ski.h>
+#include <assert.h>
 #include <console/console.h>
 #include <console/chardev.h>
@@ -238,6 +239,6 @@
 void skiin_wire(ski_instance_t *instance, indev_t *srlnin)
 {
-	ASSERT(instance);
-	ASSERT(srlnin);
+	assert(instance);
+	assert(srlnin);
 	
 	instance->srlnin = srlnin;
Index: kernel/arch/ia64/src/interrupt.c
===================================================================
--- kernel/arch/ia64/src/interrupt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/src/interrupt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,9 +35,9 @@
 
 #include <arch/interrupt.h>
+#include <assert.h>
 #include <interrupt.h>
 #include <ddi/irq.h>
 #include <panic.h>
 #include <print.h>
-#include <debug.h>
 #include <console/console.h>
 #include <typedefs.h>
@@ -123,5 +123,5 @@
 static const char *vector_to_string(unsigned int n)
 {
-	ASSERT(n <= VECTOR_MAX);
+	assert(n <= VECTOR_MAX);
 	
 	if (n >= VECTORS_16_BUNDLE_START)
Index: kernel/arch/ia64/src/mm/as.c
===================================================================
--- kernel/arch/ia64/src/mm/as.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/src/mm/as.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
 #include <arch/mm/asid.h>
 #include <arch/mm/page.h>
+#include <assert.h>
 #include <genarch/mm/as_ht.h>
 #include <genarch/mm/page_ht.h>
@@ -58,5 +59,5 @@
 	int i;
 	
-	ASSERT(as->asid != ASID_INVALID);
+	assert(as->asid != ASID_INVALID);
 	
 	/*
Index: kernel/arch/ia64/src/mm/page.c
===================================================================
--- kernel/arch/ia64/src/mm/page.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/src/mm/page.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 
 #include <arch/mm/page.h>
+#include <assert.h>
 #include <genarch/mm/page_ht.h>
 #include <mm/asid.h>
@@ -166,5 +167,5 @@
 	bool match;
 
-	ASSERT(v);
+	assert(v);
 
 	vrn = page >> VRN_SHIFT;
@@ -213,5 +214,5 @@
 	uint64_t tag;
 
-	ASSERT(v);
+	assert(v);
 
 	vrn = page >> VRN_SHIFT;
Index: kernel/arch/ia64/src/mm/tlb.c
===================================================================
--- kernel/arch/ia64/src/mm/tlb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ia64/src/mm/tlb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -48,4 +48,5 @@
 #include <arch/pal/pal.h>
 #include <arch/asm.h>
+#include <assert.h>
 #include <panic.h>
 #include <print.h>
@@ -449,5 +450,5 @@
 	entry.word[1] = 0;
 	
-	ASSERT(t->x);
+	assert(t->x);
 	
 	entry.p = t->p;
@@ -488,9 +489,9 @@
 	va = istate->cr_ifa; /* faulting address */
 	
-	ASSERT(!is_kernel_fault(va));
+	assert(!is_kernel_fault(va));
 
 	bool found = page_mapping_find(AS, va, true, &t);
 	if (found) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -605,5 +606,5 @@
 	bool found = page_mapping_find(as, va, true, &t);
 	if (found) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -634,5 +635,5 @@
 void data_nested_tlb_fault(unsigned int n, istate_t *istate)
 {
-	ASSERT(false);
+	assert(false);
 }
 
@@ -656,6 +657,6 @@
 	bool found = page_mapping_find(as, va, true, &t);
 
-	ASSERT(found);
-	ASSERT(t.p);
+	assert(found);
+	assert(t.p);
 
 	if (found && t.p && t.w) {
@@ -685,10 +686,10 @@
 	va = istate->cr_ifa;  /* faulting address */
 
-	ASSERT(!is_kernel_fault(va));
+	assert(!is_kernel_fault(va));
 	
 	bool found = page_mapping_find(AS, va, true, &t);
 
-	ASSERT(found);
-	ASSERT(t.p);
+	assert(found);
+	assert(t.p);
 
 	if (found && t.p && t.x) {
@@ -724,6 +725,6 @@
 	bool found = page_mapping_find(as, va, true, &t);
 
-	ASSERT(found);
-	ASSERT(t.p);
+	assert(found);
+	assert(t.p);
 
 	if (found && t.p) {
@@ -757,5 +758,5 @@
 	va = istate->cr_ifa;  /* faulting address */
 
-	ASSERT(!is_kernel_fault(va));
+	assert(!is_kernel_fault(va));
 	
 	/*
@@ -764,7 +765,7 @@
 	bool found = page_mapping_find(AS, va, true, &t);
 
-	ASSERT(found);
-	ASSERT(t.p);
-	ASSERT(!t.w);
+	assert(found);
+	assert(t.p);
+	assert(!t.w);
 
 	as_page_fault(va, PF_ACCESS_WRITE, istate);
@@ -784,9 +785,9 @@
 	va = istate->cr_ifa;  /* faulting address */
 	
-	ASSERT(!is_kernel_fault(va));
+	assert(!is_kernel_fault(va));
 
 	bool found = page_mapping_find(AS, va, true, &t);
 
-	ASSERT(found);
+	assert(found);
 	
 	if (t.p) {
Index: kernel/arch/mips32/src/exception.c
===================================================================
--- kernel/arch/mips32/src/exception.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/mips32/src/exception.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,5 +39,5 @@
 #include <arch/cp0.h>
 #include <arch.h>
-#include <debug.h>
+#include <assert.h>
 #include <proc/thread.h>
 #include <print.h>
@@ -120,5 +120,5 @@
 {
 	if (*((uint32_t *) istate->epc) == 0x7c03e83b) {
-		ASSERT(THREAD);
+		assert(THREAD);
 		istate->epc += 4;
 		istate->v1 = istate->kt1;
Index: kernel/arch/mips32/src/mm/tlb.c
===================================================================
--- kernel/arch/mips32/src/mm/tlb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/mips32/src/mm/tlb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -44,5 +44,5 @@
 #include <print.h>
 #include <log.h>
-#include <debug.h>
+#include <assert.h>
 #include <align.h>
 #include <interrupt.h>
@@ -160,5 +160,5 @@
 #endif
 
-	ASSERT(!index.p);
+	assert(!index.p);
 
 	badvaddr = cp0_badvaddr_read();
@@ -323,5 +323,5 @@
 	int i;
 
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 
 	hi_save.value = cp0_entry_hi_read();
@@ -356,6 +356,6 @@
 	int i;
 
-	ASSERT(interrupts_disabled());
-	ASSERT(asid != ASID_INVALID);
+	assert(interrupts_disabled());
+	assert(asid != ASID_INVALID);
 
 	hi_save.value = cp0_entry_hi_read();
@@ -398,5 +398,5 @@
 	tlb_index_t index;
 
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 	
 	if (asid == ASID_INVALID)
Index: kernel/arch/ppc32/src/mm/pht.c
===================================================================
--- kernel/arch/ppc32/src/mm/pht.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/ppc32/src/mm/pht.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 #include <arch/mm/pht.h>
 #include <arch/mm/tlb.h>
+#include <assert.h>
 #include <interrupt.h>
 #include <mm/as.h>
@@ -79,6 +80,6 @@
 		found = page_mapping_find(as, badvaddr, true, pte);
 
-		ASSERT(found);
-		ASSERT(pte->present);
+		assert(found);
+		assert(pte->present);
 
 		return found;
Index: kernel/arch/sparc64/src/drivers/pci.c
===================================================================
--- kernel/arch/sparc64/src/drivers/pci.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/drivers/pci.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -42,5 +42,5 @@
 #include <mm/slab.h>
 #include <typedefs.h>
-#include <debug.h>
+#include <assert.h>
 #include <log.h>
 #include <str.h>
@@ -175,5 +175,5 @@
 	 * First, verify this is a PCI node.
 	 */
-	ASSERT(str_cmp(ofw_tree_node_name(node), "pci") == 0);
+	assert(str_cmp(ofw_tree_node_name(node), "pci") == 0);
 
 	/*
@@ -210,5 +210,5 @@
 void pci_enable_interrupt(pci_t *pci, int inr)
 {
-	ASSERT(pci->op && pci->op->enable_interrupt);
+	assert(pci->op && pci->op->enable_interrupt);
 	pci->op->enable_interrupt(pci, inr);
 }
@@ -218,5 +218,5 @@
 	pci_t *pci = (pci_t *)pcip;
 
-	ASSERT(pci->op && pci->op->clear_interrupt);
+	assert(pci->op && pci->op->clear_interrupt);
 	pci->op->clear_interrupt(pci, inr);
 }
Index: kernel/arch/sparc64/src/drivers/tick.c
===================================================================
--- kernel/arch/sparc64/src/drivers/tick.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/drivers/tick.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -43,5 +43,5 @@
 #include <time/clock.h>
 #include <arch.h>
-#include <debug.h>
+#include <assert.h>
 
 /** Initialize tick and stick interrupt. */
@@ -93,10 +93,10 @@
 	 * Make sure we are servicing interrupt_level_14
 	 */
-	ASSERT(n == TT_INTERRUPT_LEVEL_14);
+	assert(n == TT_INTERRUPT_LEVEL_14);
 	
 	/*
 	 * Make sure we are servicing TICK_INT.
 	 */
-	ASSERT(softint.tick_int);
+	assert(softint.tick_int);
 
 	/*
Index: kernel/arch/sparc64/src/mm/sun4u/as.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4u/as.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4u/as.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,8 +35,8 @@
 #include <arch/mm/as.h>
 #include <arch/mm/tlb.h>
+#include <assert.h>
+#include <config.h>
 #include <genarch/mm/page_ht.h>
 #include <genarch/mm/asid_fifo.h>
-#include <debug.h>
-#include <config.h>
 
 #ifdef CONFIG_TSB
@@ -130,6 +130,6 @@
 	uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
 	
-	ASSERT(as->arch.itsb);
-	ASSERT(as->arch.dtsb);
+	assert(as->arch.itsb);
+	assert(as->arch.dtsb);
 	
 	uintptr_t tsb = (uintptr_t) as->arch.itsb;
@@ -202,6 +202,6 @@
 	uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
 	
-	ASSERT(as->arch.itsb);
-	ASSERT(as->arch.dtsb);
+	assert(as->arch.itsb);
+	assert(as->arch.dtsb);
 	
 	uintptr_t tsb = (uintptr_t) as->arch.itsb;
Index: kernel/arch/sparc64/src/mm/sun4u/tlb.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4u/tlb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4u/tlb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -41,4 +41,5 @@
 #include <arch/mm/mmu.h>
 #include <arch/interrupt.h>
+#include <assert.h>
 #include <interrupt.h>
 #include <arch.h>
@@ -201,5 +202,5 @@
 	bool found = page_mapping_find(AS, istate->tpc, true, &t);
 	if (found && PTE_EXECUTABLE(&t)) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -258,5 +259,5 @@
 	bool found = page_mapping_find(as, page_16k, true, &t);
 	if (found) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -301,5 +302,5 @@
 	bool found = page_mapping_find(as, page_16k, true, &t);
 	if (found && PTE_WRITABLE(&t)) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
Index: kernel/arch/sparc64/src/mm/sun4u/tsb.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4u/tsb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4u/tsb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup sparc64mm	
+/** @addtogroup sparc64mm
  * @{
  */
@@ -37,8 +37,8 @@
 #include <arch/mm/page.h>
 #include <arch/barrier.h>
+#include <assert.h>
 #include <mm/as.h>
 #include <typedefs.h>
 #include <macros.h>
-#include <debug.h>
 
 /** Invalidate portion of TSB.
@@ -58,6 +58,6 @@
 	size_t cnt;
 	
-	ASSERT(as->arch.itsb);
-	ASSERT(as->arch.dtsb);
+	assert(as->arch.itsb);
+	assert(as->arch.dtsb);
 	
 	i0 = (page >> MMU_PAGE_WIDTH) & ITSB_ENTRY_MASK;
@@ -85,5 +85,5 @@
 	size_t entry;
 
-	ASSERT(index <= 1);
+	assert(index <= 1);
 	
 	as = t->as;
@@ -130,5 +130,5 @@
 	size_t entry;
 	
-	ASSERT(index <= 1);
+	assert(index <= 1);
 
 	as = t->as;
Index: kernel/arch/sparc64/src/mm/sun4v/as.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4v/as.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4v/as.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,7 +37,7 @@
 #include <arch/mm/pagesize.h>
 #include <arch/mm/tlb.h>
+#include <assert.h>
 #include <genarch/mm/page_ht.h>
 #include <genarch/mm/asid_fifo.h>
-#include <debug.h>
 #include <config.h>
 #include <arch/sun4v/hypercall.h>
@@ -121,5 +121,5 @@
 	uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
 	
-	ASSERT(as->arch.tsb_description.tsb_base);
+	assert(as->arch.tsb_description.tsb_base);
 	uintptr_t tsb = PA2KA(as->arch.tsb_description.tsb_base);
 	
@@ -160,5 +160,5 @@
 	uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
 	
-	ASSERT(as->arch.tsb_description.tsb_base);
+	assert(as->arch.tsb_description.tsb_base);
 	
 	uintptr_t tsb = PA2KA(as->arch.tsb_description.tsb_base);
Index: kernel/arch/sparc64/src/mm/sun4v/tlb.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4v/tlb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4v/tlb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -43,4 +43,5 @@
 #include <arch/mm/tlb.h>
 #include <arch/interrupt.h>
+#include <assert.h>
 #include <interrupt.h>
 #include <arch.h>
@@ -215,5 +216,5 @@
 	bool found = page_mapping_find(AS, va, true, &t);
 	if (found && PTE_EXECUTABLE(&t)) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -265,5 +266,5 @@
 	bool found = page_mapping_find(as, va, true, &t);
 	if (found) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -303,5 +304,5 @@
 	bool found = page_mapping_find(as, va, true, &t);
 	if (found && PTE_WRITABLE(&t)) {
-		ASSERT(t.p);
+		assert(t.p);
 
 		/*
@@ -345,5 +346,5 @@
 	__hypercall_fast_ret1(0, 0, 0, 0, 0, CPU_MYID, &myid);
 
-	ASSERT(mmu_fsas[myid].dft < 16);
+	assert(mmu_fsas[myid].dft < 16);
 
 	printf("condition which caused the fault: %s\n",
Index: kernel/arch/sparc64/src/mm/sun4v/tsb.c
===================================================================
--- kernel/arch/sparc64/src/mm/sun4v/tsb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/mm/sun4v/tsb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,8 +39,8 @@
 #include <arch/mm/page.h>
 #include <arch/barrier.h>
+#include <assert.h>
 #include <mm/as.h>
 #include <typedefs.h>
 #include <macros.h>
-#include <debug.h>
 
 /** Invalidate portion of TSB.
@@ -60,5 +60,5 @@
 	size_t cnt;
 	
-	ASSERT(as->arch.tsb_description.tsb_base);
+	assert(as->arch.tsb_description.tsb_base);
 	
 	i0 = (page >> MMU_PAGE_WIDTH) & TSB_ENTRY_MASK;
Index: kernel/arch/sparc64/src/smp/sun4u/ipi.c
===================================================================
--- kernel/arch/sparc64/src/smp/sun4u/ipi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/smp/sun4u/ipi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
 #include <smp/ipi.h>
 #include <arch/smp/sun4u/ipi.h>
+#include <assert.h>
 #include <cpu.h>
 #include <arch.h>
@@ -103,5 +104,5 @@
 		panic("Interrupt Dispatch Status busy bit set\n");
 	
-	ASSERT(!(pstate_read() & PSTATE_IE_BIT));
+	assert(!(pstate_read() & PSTATE_IE_BIT));
 	
 	do {
@@ -185,5 +186,5 @@
 void ipi_unicast_arch(unsigned int cpu_id, int ipi)
 {
-	ASSERT(&cpus[cpu_id] != CPU);
+	assert(&cpus[cpu_id] != CPU);
 	
 	if (ipi == IPI_SMP_CALL) {
Index: kernel/arch/sparc64/src/sparc64.c
===================================================================
--- kernel/arch/sparc64/src/sparc64.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/arch/sparc64/src/sparc64.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -70,5 +70,5 @@
 
 	if (config.cpu_active == 1) {
-		STATIC_ASSERT(UWB_SIZE <= UWB_ALIGNMENT);
+		static_assert(UWB_SIZE <= UWB_ALIGNMENT, "");
 		/* Create slab cache for the userspace window buffers */
 		uwb_cache = slab_cache_create("uwb_cache", UWB_SIZE,
Index: kernel/genarch/include/genarch/drivers/amdm37x/gpt.h
===================================================================
--- kernel/genarch/include/genarch/drivers/amdm37x/gpt.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/include/genarch/drivers/amdm37x/gpt.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,4 +37,5 @@
 #define KERN_AMDM37x_GPT_H_
 
+#include <assert.h>
 #include <typedefs.h>
 #include <mm/km.h>
@@ -211,5 +212,5 @@
 	km_unmap((uintptr_t)clksel, 4);
 
-	ASSERT(timer);
+	assert(timer);
 	/* Map control register */
 	timer->regs = (void*) km_map(ioregs, iosize, PAGE_NOT_CACHEABLE);
@@ -247,6 +248,6 @@
 static inline void amdm37x_gpt_timer_ticks_start(amdm37x_gpt_t* timer)
 {
-	ASSERT(timer);
-	ASSERT(timer->regs);
+	assert(timer);
+	assert(timer->regs);
 	/* Enable overflow interrupt */
 	timer->regs->tier |= AMDM37x_GPT_TIER_OVF_IRQ_FLAG;
@@ -257,6 +258,6 @@
 static inline bool amdm37x_gpt_irq_ack(amdm37x_gpt_t* timer)
 {
-	ASSERT(timer);
-	ASSERT(timer->regs);
+	assert(timer);
+	assert(timer->regs);
 	/* Clear all pending interrupts */
 	const uint32_t tisr = timer->regs->tisr;
Index: kernel/genarch/include/genarch/drivers/bcm2835/irc.h
===================================================================
--- kernel/genarch/include/genarch/drivers/bcm2835/irc.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/include/genarch/drivers/bcm2835/irc.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
 #define KERN_BCM2835_IRQC_H_
 
+#include <assert.h>
 #include <typedefs.h>
 
@@ -158,5 +159,5 @@
 static inline void bcm2835_irc_enable(bcm2835_irc_t *regs, unsigned inum)
 {
-	ASSERT(inum < BCM2835_IRQ_COUNT);
+	assert(inum < BCM2835_IRQ_COUNT);
 	regs->irq_enable[IRQ_TO_BANK(inum)] |= (1 << IRQ_TO_NUM(inum));
 }
@@ -164,5 +165,5 @@
 static inline void bcm2835_irc_disable(bcm2835_irc_t *regs, unsigned inum)
 {
-	ASSERT(inum < BCM2835_IRQ_COUNT);
+	assert(inum < BCM2835_IRQ_COUNT);
 	regs->irq_disable[IRQ_TO_BANK(inum)] |= (1 << IRQ_TO_NUM(inum));
 }
Index: kernel/genarch/include/genarch/drivers/bcm2835/timer.h
===================================================================
--- kernel/genarch/include/genarch/drivers/bcm2835/timer.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/include/genarch/drivers/bcm2835/timer.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
 #ifndef KERN_BCM2835_TIMER_H_
 
+#include <assert.h>
 #include <typedefs.h>
 #include <mm/km.h>
@@ -66,5 +67,5 @@
 static inline void bcm2835_timer_start(bcm2835_timer_t* timer)
 {
-	ASSERT(timer);
+	assert(timer);
 	/* Clear pending interrupt on channel 1 */
 	timer->cs |= BCM2835_TIMER_CS_M1;
@@ -75,5 +76,5 @@
 static inline void bcm2835_timer_irq_ack(bcm2835_timer_t* timer)
 {
-	ASSERT(timer);
+	assert(timer);
 	/* Clear pending interrupt on channel 1 */
 	timer->cs |= BCM2835_TIMER_CS_M1;
Index: kernel/genarch/include/genarch/drivers/omap/irc.h
===================================================================
--- kernel/genarch/include/genarch/drivers/omap/irc.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/include/genarch/drivers/omap/irc.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,4 +39,5 @@
 #define KERN_OMAP_IRQC_H_
 
+#include <assert.h>
 #include <typedefs.h>
 
@@ -230,5 +231,5 @@
 static inline void omap_irc_enable(omap_irc_regs_t *regs, unsigned inum)
 {
-	ASSERT(inum < OMAP_IRC_IRQ_COUNT);
+	assert(inum < OMAP_IRC_IRQ_COUNT);
 	const unsigned set = inum / 32;
 	const unsigned pos = inum % 32;
@@ -243,5 +244,5 @@
 static inline void omap_irc_disable(omap_irc_regs_t *regs, unsigned inum)
 {
-	ASSERT(inum < OMAP_IRC_IRQ_COUNT);
+	assert(inum < OMAP_IRC_IRQ_COUNT);
 	const unsigned set = inum / 32;
 	const unsigned pos = inum % 32;
Index: kernel/genarch/include/genarch/drivers/pl050/pl050.h
===================================================================
--- kernel/genarch/include/genarch/drivers/pl050/pl050.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/include/genarch/drivers/pl050/pl050.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup genarch		
+/** @addtogroup genarch
  * @{
  */
Index: kernel/genarch/src/acpi/acpi.c
===================================================================
--- kernel/genarch/src/acpi/acpi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/acpi/acpi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,4 +39,5 @@
 #include <genarch/acpi/madt.h>
 #include <arch/bios/bios.h>
+#include <debug.h>
 #include <mm/page.h>
 #include <mm/km.h>
Index: kernel/genarch/src/acpi/madt.c
===================================================================
--- kernel/genarch/src/acpi/madt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/acpi/madt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <typedefs.h>
 #include <genarch/acpi/acpi.h>
@@ -41,5 +42,4 @@
 #include <arch/smp/smp.h>
 #include <panic.h>
-#include <debug.h>
 #include <config.h>
 #include <log.h>
@@ -82,5 +82,5 @@
 static uint8_t madt_cpu_apic_id(size_t i)
 {
-	ASSERT(i < madt_l_apic_entry_cnt);
+	assert(i < madt_l_apic_entry_cnt);
 	
 	return ((struct madt_l_apic *)
@@ -90,5 +90,5 @@
 static bool madt_cpu_enabled(size_t i)
 {
-	ASSERT(i < madt_l_apic_entry_cnt);
+	assert(i < madt_l_apic_entry_cnt);
 	
 	/*
@@ -106,5 +106,5 @@
 static bool madt_cpu_bootstrap(size_t i)
 {
-	ASSERT(i < madt_l_apic_entry_cnt);
+	assert(i < madt_l_apic_entry_cnt);
 	
 	return ((struct madt_l_apic *)
@@ -176,5 +176,5 @@
     size_t i)
 {
-	ASSERT(override->source < sizeof(isa_irq_map) / sizeof(int));
+	assert(override->source < sizeof(isa_irq_map) / sizeof(int));
 	
 	isa_irq_map[override->source] = override->global_int;
Index: kernel/genarch/src/drivers/am335x/timer.c
===================================================================
--- kernel/genarch/src/drivers/am335x/timer.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/am335x/timer.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/am335x/timer.h>
 #include <mm/km.h>
@@ -90,6 +91,6 @@
 	size_t size;
 
-	ASSERT(id < TIMERS_MAX);
-	ASSERT(timer != NULL);
+	assert(id < TIMERS_MAX);
+	assert(timer != NULL);
 
 	if (id == DMTIMER1_1MS)
@@ -100,5 +101,5 @@
 
 	timer->regs = (void *) km_map(base_addr, size, PAGE_NOT_CACHEABLE);
-	ASSERT(timer->regs != NULL);
+	assert(timer->regs != NULL);
 
 	timer->id = id;
Index: kernel/genarch/src/drivers/dsrln/dsrlnin.c
===================================================================
--- kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/dsrln/dsrlnin.h>
 #include <console/chardev.h>
@@ -75,6 +76,6 @@
 void dsrlnin_wire(dsrlnin_instance_t *instance, indev_t *srlnin)
 {
-	ASSERT(instance);
-	ASSERT(srlnin);
+	assert(instance);
+	assert(srlnin);
 	
 	instance->srlnin = srlnin;
Index: kernel/genarch/src/drivers/ega/ega.c
===================================================================
--- kernel/genarch/src/drivers/ega/ega.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/ega/ega.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <debug.h>
 #include <genarch/drivers/ega/ega.h>
 #include <putchar.h>
Index: kernel/genarch/src/drivers/i8042/i8042.c
===================================================================
--- kernel/genarch/src/drivers/i8042/i8042.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/i8042/i8042.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/i8042/i8042.h>
 #include <genarch/drivers/legacy/ia32/io.h>
@@ -124,6 +125,6 @@
 void i8042_wire(i8042_instance_t *instance, indev_t *kbrdin)
 {
-	ASSERT(instance);
-	ASSERT(kbrdin);
+	assert(instance);
+	assert(kbrdin);
 	
 	i8042_clear_buffer(instance->i8042);
Index: kernel/genarch/src/drivers/ns16550/ns16550.c
===================================================================
--- kernel/genarch/src/drivers/ns16550/ns16550.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/ns16550/ns16550.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/ns16550/ns16550.h>
 #include <ddi/irq.h>
@@ -157,6 +158,6 @@
 void ns16550_wire(ns16550_instance_t *instance, indev_t *input)
 {
-	ASSERT(instance);
-	ASSERT(input);
+	assert(instance);
+	assert(input);
 	
 	instance->input = input;
Index: kernel/genarch/src/drivers/omap/uart.c
===================================================================
--- kernel/genarch/src/drivers/omap/uart.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/omap/uart.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/omap/uart.h>
 #include <ddi/device.h>
@@ -86,8 +87,8 @@
     omap_uart_t *uart, inr_t interrupt, uintptr_t addr, size_t size)
 {
-	ASSERT(uart);
+	assert(uart);
 	uart->regs = (void *)km_map(addr, size, PAGE_NOT_CACHEABLE);
 
-	ASSERT(uart->regs);
+	assert(uart->regs);
 
 	/* Soft reset the port */
@@ -171,5 +172,5 @@
 void omap_uart_input_wire(omap_uart_t *uart, indev_t *indev)
 {
-	ASSERT(uart);
+	assert(uart);
 	/* Set indev */
 	uart->indev = indev;
Index: kernel/genarch/src/drivers/pl011/pl011.c
===================================================================
--- kernel/genarch/src/drivers/pl011/pl011.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/pl011/pl011.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/pl011/pl011.h>
 #include <console/chardev.h>
@@ -98,8 +99,8 @@
 bool pl011_uart_init(pl011_uart_t *uart, inr_t interrupt, uintptr_t addr)
 {
-	ASSERT(uart);
+	assert(uart);
 	uart->regs = (void*)km_map(addr, sizeof(pl011_uart_regs_t),
 				   PAGE_NOT_CACHEABLE);
-	ASSERT(uart->regs);
+	assert(uart->regs);
 
 	/* Disable UART */
@@ -137,6 +138,6 @@
 void pl011_uart_input_wire(pl011_uart_t *uart, indev_t *indev)
 {
-	ASSERT(uart);
-	ASSERT(indev);
+	assert(uart);
+	assert(indev);
 
 	uart->indev = indev;
Index: kernel/genarch/src/drivers/s3c24xx/uart.c
===================================================================
--- kernel/genarch/src/drivers/s3c24xx/uart.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/s3c24xx/uart.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/s3c24xx/uart.h>
 #include <console/chardev.h>
@@ -161,6 +162,6 @@
 void s3c24xx_uart_input_wire(s3c24xx_uart_t *uart, indev_t *indev)
 {
-	ASSERT(uart);
-	ASSERT(indev);
+	assert(uart);
+	assert(indev);
 
 	uart->indev = indev;
Index: kernel/genarch/src/drivers/via-cuda/cuda.c
===================================================================
--- kernel/genarch/src/drivers/via-cuda/cuda.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/drivers/via-cuda/cuda.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
  */
 
+#include <assert.h>
 #include <genarch/drivers/via-cuda/cuda.h>
 #include <console/chardev.h>
@@ -123,6 +124,6 @@
 	cuda_t *dev = instance->cuda;
 
-	ASSERT(instance);
-	ASSERT(kbrdin);
+	assert(instance);
+	assert(kbrdin);
 
 	instance->kbrdin = kbrdin;
@@ -341,5 +342,5 @@
 	cuda_t *dev = instance->cuda;
 
-	ASSERT(instance->xstate == cx_listen);
+	assert(instance->xstate == cx_listen);
 
 	if (instance->snd_bytes == 0)
Index: kernel/genarch/src/fb/bfb.c
===================================================================
--- kernel/genarch/src/fb/bfb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/fb/bfb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <debug.h>
 #include <typedefs.h>
 #include <genarch/fb/fb.h>
Index: kernel/genarch/src/fb/fb.c
===================================================================
--- kernel/genarch/src/fb/fb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/fb/fb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,6 @@
  */
 
+#include <assert.h>
+#include <debug.h>
 #include <genarch/fb/font-8x16.h>
 #include <genarch/fb/fb.h>
@@ -511,8 +513,8 @@
 outdev_t *fb_init(fb_properties_t *props)
 {
-	ASSERT(props);
-	ASSERT(props->x > 0);
-	ASSERT(props->y > 0);
-	ASSERT(props->scan > 0);
+	assert(props);
+	assert(props->x > 0);
+	assert(props->y > 0);
+	assert(props->scan > 0);
 	
 	rgb_conv_t rgb_conv;
Index: kernel/genarch/src/kbrd/kbrd.c
===================================================================
--- kernel/genarch/src/kbrd/kbrd.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/kbrd/kbrd.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/kbrd/kbrd.h>
 #include <genarch/kbrd/scanc.h>
@@ -194,6 +195,6 @@
 indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
 {
-	ASSERT(instance);
-	ASSERT(sink);
+	assert(instance);
+	assert(sink);
 	
 	instance->sink = sink;
Index: kernel/genarch/src/kbrd/kbrd_at.c
===================================================================
--- kernel/genarch/src/kbrd/kbrd_at.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/kbrd/kbrd_at.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/kbrd/kbrd.h>
 #include <genarch/kbrd/scanc.h>
@@ -192,6 +193,6 @@
 indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
 {
-	ASSERT(instance);
-	ASSERT(sink);
+	assert(instance);
+	assert(sink);
 	
 	instance->sink = sink;
Index: kernel/genarch/src/mm/asid.c
===================================================================
--- kernel/genarch/src/mm/asid.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/mm/asid.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -57,4 +57,5 @@
  */
 
+#include <assert.h>
 #include <mm/asid.h>
 #include <mm/as.h>
@@ -64,5 +65,4 @@
 #include <synch/mutex.h>
 #include <adt/list.h>
-#include <debug.h>
 
 static size_t asids_allocated = 0;
@@ -78,6 +78,6 @@
 	as_t *as;
 
-	ASSERT(interrupts_disabled());
-	ASSERT(spinlock_locked(&asidlock));
+	assert(interrupts_disabled());
+	assert(spinlock_locked(&asidlock));
 
 	/*
@@ -98,5 +98,5 @@
 		 */
 		tmp = list_first(&inactive_as_with_asid_list);
-		ASSERT(tmp != NULL);
+		assert(tmp != NULL);
 		list_remove(tmp);
 		
@@ -108,5 +108,5 @@
 		 */
 		asid = as->asid;
-		ASSERT(asid != ASID_INVALID);
+		assert(asid != ASID_INVALID);
 
 		/*
Index: kernel/genarch/src/mm/page_ht.c
===================================================================
--- kernel/genarch/src/mm/page_ht.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/mm/page_ht.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -48,5 +48,5 @@
 #include <synch/spinlock.h>
 #include <arch.h>
-#include <debug.h>
+#include <assert.h>
 #include <adt/hash_table.h>
 #include <align.h>
@@ -137,7 +137,7 @@
 bool compare(sysarg_t key[], size_t keys, link_t *item)
 {
-	ASSERT(item);
-	ASSERT(keys > 0);
-	ASSERT(keys <= PAGE_HT_KEYS);
+	assert(item);
+	assert(keys > 0);
+	assert(keys <= PAGE_HT_KEYS);
 	
 	/*
@@ -161,5 +161,5 @@
 void remove_callback(link_t *item)
 {
-	ASSERT(item);
+	assert(item);
 	
 	/*
@@ -191,5 +191,5 @@
 	};
 
-	ASSERT(page_table_locked(as));
+	assert(page_table_locked(as));
 
 	irq_spinlock_lock(&page_ht_lock, true);
@@ -197,5 +197,5 @@
 	if (!hash_table_find(&page_ht, key)) {
 		pte_t *pte = slab_alloc(pte_cache, FRAME_LOWMEM | FRAME_ATOMIC);
-		ASSERT(pte != NULL);
+		assert(pte != NULL);
 		
 		pte->g = (flags & PAGE_GLOBAL) != 0;
@@ -241,5 +241,5 @@
 	};
 
-	ASSERT(page_table_locked(as));
+	assert(page_table_locked(as));
 	
 	irq_spinlock_lock(&page_ht_lock, true);
@@ -261,5 +261,5 @@
 	};
 
-	ASSERT(nolock || page_table_locked(as));
+	assert(nolock || page_table_locked(as));
 
 	link_t *cur = hash_table_find(&page_ht, key);
@@ -307,13 +307,13 @@
 		panic("Updating non-existent PTE");
 	
-	ASSERT(pte->as == t->as);
-	ASSERT(pte->page == t->page);
-	ASSERT(pte->frame == t->frame);
-	ASSERT(pte->g == t->g);
-	ASSERT(pte->x == t->x);
-	ASSERT(pte->w == t->w);
-	ASSERT(pte->k == t->k);
-	ASSERT(pte->c == t->c);
-	ASSERT(pte->p == t->p);
+	assert(pte->as == t->as);
+	assert(pte->page == t->page);
+	assert(pte->frame == t->frame);
+	assert(pte->g == t->g);
+	assert(pte->x == t->x);
+	assert(pte->w == t->w);
+	assert(pte->k == t->k);
+	assert(pte->c == t->c);
+	assert(pte->p == t->p);
 
 	t->a = pte->a;
Index: kernel/genarch/src/mm/page_pt.c
===================================================================
--- kernel/genarch/src/mm/page_pt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/mm/page_pt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
  */
 
+#include <assert.h>
 #include <genarch/mm/page_pt.h>
 #include <mm/page.h>
@@ -81,5 +82,5 @@
 	pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
 
-	ASSERT(page_table_locked(as));
+	assert(page_table_locked(as));
 	
 	if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
@@ -159,5 +160,5 @@
 void pt_mapping_remove(as_t *as, uintptr_t page)
 {
-	ASSERT(page_table_locked(as));
+	assert(page_table_locked(as));
 
 	/*
@@ -293,5 +294,5 @@
 static pte_t *pt_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
 {
-	ASSERT(nolock || page_table_locked(as));
+	assert(nolock || page_table_locked(as));
 
 	pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
@@ -358,9 +359,9 @@
 		panic("Updating non-existent PTE");	
 
-	ASSERT(PTE_VALID(t) == PTE_VALID(pte));
-	ASSERT(PTE_PRESENT(t) == PTE_PRESENT(pte));
-	ASSERT(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
-	ASSERT(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
-	ASSERT(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
+	assert(PTE_VALID(t) == PTE_VALID(pte));
+	assert(PTE_PRESENT(t) == PTE_PRESENT(pte));
+	assert(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
+	assert(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
+	assert(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
 
 	*t = *pte;
@@ -398,5 +399,5 @@
 void pt_mapping_make_global(uintptr_t base, size_t size)
 {
-	ASSERT(size > 0);
+	assert(size > 0);
 	
 	uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
@@ -416,5 +417,5 @@
 	    addr += ptl0_step) {
 		if (GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr)) != 0) {
-			ASSERT(overlaps(addr, ptl0_step,
+			assert(overlaps(addr, ptl0_step,
 			    config.identity_base, config.identity_size));
 
Index: kernel/genarch/src/ofw/ebus.c
===================================================================
--- kernel/genarch/src/ofw/ebus.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/ofw/ebus.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
  */
 
+#include <assert.h>
 #include <genarch/ofw/ofw_tree.h>
 #include <genarch/ofw/ebus.h>
@@ -41,5 +42,4 @@
 #include <str.h>
 #include <panic.h>
-#include <debug.h>
 #include <macros.h>
 
@@ -94,5 +94,5 @@
 	size_t count = prop->size / sizeof(ofw_ebus_intr_map_t);
 	
-	ASSERT(count);
+	assert(count);
 	
 	prop = ofw_tree_getprop(node, "interrupt-map-mask");
@@ -102,5 +102,5 @@
 	ofw_ebus_intr_mask_t *intr_mask = prop->value;
 	
-	ASSERT(prop->size == sizeof(ofw_ebus_intr_mask_t));
+	assert(prop->size == sizeof(ofw_ebus_intr_mask_t));
 	
 	uint32_t space = reg->space & intr_mask->space_mask;
Index: kernel/genarch/src/srln/srln.c
===================================================================
--- kernel/genarch/src/srln/srln.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/genarch/src/srln/srln.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <genarch/srln/srln.h>
 #include <console/chardev.h>
@@ -148,6 +149,6 @@
 indev_t *srln_wire(srln_instance_t *instance, indev_t *sink)
 {
-	ASSERT(instance);
-	ASSERT(sink);
+	assert(instance);
+	assert(sink);
 	
 	instance->sink = sink;
Index: kernel/generic/include/adt/list.h
===================================================================
--- kernel/generic/include/adt/list.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/include/adt/list.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,5 +37,5 @@
 #define KERN_LIST_H_
 
-#include <debug.h>
+#include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -120,5 +120,5 @@
 	
 #define assert_link_not_used(link) \
-	ASSERT(!link_used(link))
+	assert(!link_used(link))
 
 /** Initialize doubly-linked circular list link
@@ -390,5 +390,5 @@
 		return false;
 
-	ASSERT(link->prev != NULL && link->next != NULL);
+	assert(link->prev != NULL && link->next != NULL);
 	return true;
 }
Index: kernel/generic/include/assert.h
===================================================================
--- kernel/generic/include/assert.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
+++ kernel/generic/include/assert.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2005 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup genericdebug
+ * @{
+ */
+/** @file
+ */
+
+#ifndef KERN_ASSERT_H_
+#define KERN_ASSERT_H_
+
+#include <panic.h>
+
+#ifdef CONFIG_DEBUG
+
+/** Debugging assert macro
+ *
+ * If CONFIG_DEBUG is set, the assert() macro
+ * evaluates expr and if it is false raises
+ * kernel panic.
+ *
+ * @param expr Expression which is expected to be true.
+ *
+ */
+#define assert(expr) \
+	do { \
+		if (!(expr)) \
+			panic_assert("%s() at %s:%u:\n%s", \
+			    __func__, __FILE__, __LINE__, #expr); \
+	} while (0)
+
+/** Debugging verbose assert macro
+ *
+ * If CONFIG_DEBUG is set, the assert_verbose() macro
+ * evaluates expr and if it is false raises
+ * kernel panic. The panic message contains also
+ * the supplied message.
+ *
+ * @param expr Expression which is expected to be true.
+ * @param msg  Additional message to show (string).
+ *
+ */
+#define assert_verbose(expr, msg) \
+	do { \
+		if (!(expr)) \
+			panic_assert("%s() at %s:%u:\n%s, %s", \
+			    __func__, __FILE__, __LINE__, #expr, msg); \
+	} while (0)
+
+/** Static assert macro
+ *
+ */
+#define static_assert \
+	_Static_assert
+
+#else /* CONFIG_DEBUG */
+
+#define assert(expr)
+#define assert_verbose(expr, msg)
+#define static_assert(expr, msg)
+
+#endif /* CONFIG_DEBUG */
+
+#endif
+
+/** @}
+ */
Index: kernel/generic/include/debug.h
===================================================================
--- kernel/generic/include/debug.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/include/debug.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,64 +36,8 @@
 #define KERN_DEBUG_H_
 
-#include <panic.h>
 #include <log.h>
 #include <symtab_lookup.h>
 
 #define CALLER  ((uintptr_t) __builtin_return_address(0))
-
-#ifdef CONFIG_DEBUG
-
-/** Debugging ASSERT macro
- *
- * If CONFIG_DEBUG is set, the ASSERT() macro
- * evaluates expr and if it is false raises
- * kernel panic.
- *
- * @param expr Expression which is expected to be true.
- *
- */
-#define ASSERT(expr) \
-	do { \
-		if (!(expr)) \
-			panic_assert("%s() at %s:%u:\n%s", \
-			    __func__, __FILE__, __LINE__, #expr); \
-	} while (0)
-
-/** Debugging verbose ASSERT macro
- *
- * If CONFIG_DEBUG is set, the ASSERT() macro
- * evaluates expr and if it is false raises
- * kernel panic. The panic message contains also
- * the supplied message.
- *
- * @param expr Expression which is expected to be true.
- * @param msg  Additional message to show (string).
- *
- */
-#define ASSERT_VERBOSE(expr, msg) \
-	do { \
-		if (!(expr)) \
-			panic_assert("%s() at %s:%u:\n%s, %s", \
-			    __func__, __FILE__, __LINE__, #expr, msg); \
-	} while (0)
-
-/** Static assert macro
- *
- */
-#define STATIC_ASSERT(expr) \
-	_Static_assert(expr, "")
-
-#define STATIC_ASSERT_VERBOSE(expr, msg) \
-	_Static_assert(expr, msg)
-
-
-#else /* CONFIG_DEBUG */
-
-#define ASSERT(expr)
-#define ASSERT_VERBOSE(expr, msg)
-#define STATIC_ASSERT(expr)
-#define STATIC_ASSERT_VERBOSE(expr, msg)
-
-#endif /* CONFIG_DEBUG */
 
 #ifdef CONFIG_LOG
Index: kernel/generic/include/preemption.h
===================================================================
--- kernel/generic/include/preemption.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/include/preemption.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,6 +37,6 @@
 
 #include <arch.h>
+#include <assert.h>
 #include <compiler/barrier.h>
-#include <debug.h>
 
 #define PREEMPTION_INC         (1 << 0)
@@ -54,5 +54,5 @@
 #define preemption_enable() \
 	do { \
-		ASSERT(PREEMPTION_DISABLED); \
+		assert(PREEMPTION_DISABLED); \
 		compiler_barrier(); \
 		THE->preemption -= PREEMPTION_INC; \
Index: kernel/generic/include/synch/rcu.h
===================================================================
--- kernel/generic/include/synch/rcu.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/include/synch/rcu.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
 #define KERN_RCU_H_
 
+#include <assert.h>
 #include <synch/rcu_types.h>
 #include <compiler/barrier.h>
@@ -162,5 +163,5 @@
 static inline void _rcu_record_qs(void)
 {
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
 	/* 
@@ -207,5 +208,5 @@
 static inline void rcu_read_lock(void)
 {
-	ASSERT(CPU);
+	assert(CPU);
 	preemption_disable();
 
@@ -222,5 +223,5 @@
 static inline void rcu_read_unlock(void)
 {
-	ASSERT(CPU);
+	assert(CPU);
 	preemption_disable();
 	
Index: kernel/generic/include/synch/spinlock.h
===================================================================
--- kernel/generic/include/synch/spinlock.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/include/synch/spinlock.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,7 +38,7 @@
 #include <stdbool.h>
 #include <arch/barrier.h>
+#include <assert.h>
 #include <preemption.h>
 #include <atomic.h>
-#include <debug.h>
 #include <arch/asm.h>
 
@@ -80,5 +80,5 @@
 
 #define ASSERT_SPINLOCK(expr, lock) \
-	ASSERT_VERBOSE(expr, (lock)->name)
+	assert_verbose(expr, (lock)->name)
 
 #define spinlock_lock(lock)    spinlock_lock_debug((lock))
@@ -98,5 +98,5 @@
 
 #define ASSERT_SPINLOCK(expr, lock) \
-	ASSERT(expr)
+	assert(expr)
 
 #define spinlock_lock(lock)    atomic_lock_arch(&(lock)->val)
@@ -175,5 +175,5 @@
 #define SPINLOCK_STATIC_INITIALIZE_NAME(name, desc_name)
 
-#define ASSERT_SPINLOCK(expr, lock)  ASSERT(expr)
+#define ASSERT_SPINLOCK(expr, lock)  assert(expr)
 
 #define spinlock_initialize(lock, name)
Index: kernel/generic/src/adt/avl.c
===================================================================
--- kernel/generic/src/adt/avl.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/adt/avl.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -51,5 +51,5 @@
 
 #include <adt/avl.h>
-#include <debug.h>
+#include <assert.h>
 
 #define LEFT 	0
@@ -165,6 +165,6 @@
 	avltree_key_t key;
 
-	ASSERT(t);
-	ASSERT(newnode);
+	assert(t);
+	assert(newnode);
 
 	/*
@@ -259,5 +259,5 @@
 			 * LR rotation.
 			 */
-			ASSERT(par->balance == 1);
+			assert(par->balance == 1);
 			
 			REBALANCE_INSERT_LR();
@@ -274,5 +274,5 @@
 			 * RL rotation.
 			 */
-			ASSERT(par->balance == -1);
+			assert(par->balance == -1);
 		
 			REBALANCE_INSERT_RL();
@@ -322,5 +322,5 @@
 				*dir = LEFT;
 		} else {
-			ASSERT(u->par->rgt == v);
+			assert(u->par->rgt == v);
 			if (!ro)
 				u->par->rgt = w;
@@ -373,6 +373,6 @@
 	int dir;
 
-	ASSERT(t);
-	ASSERT(node);
+	assert(t);
+	assert(node);
 	
 	if (node->lft == NULL) {
Index: kernel/generic/src/adt/bitmap.c
===================================================================
--- kernel/generic/src/adt/bitmap.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/adt/bitmap.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -40,8 +40,8 @@
 
 #include <adt/bitmap.h>
+#include <align.h>
+#include <assert.h>
+#include <macros.h>
 #include <typedefs.h>
-#include <align.h>
-#include <debug.h>
-#include <macros.h>
 
 #define ALL_ONES    0xff
@@ -112,5 +112,5 @@
 void bitmap_set_range(bitmap_t *bitmap, size_t start, size_t count)
 {
-	ASSERT(start + count <= bitmap->elements);
+	assert(start + count <= bitmap->elements);
 	
 	if (count == 0)
@@ -166,5 +166,5 @@
 void bitmap_clear_range(bitmap_t *bitmap, size_t start, size_t count)
 {
-	ASSERT(start + count <= bitmap->elements);
+	assert(start + count <= bitmap->elements);
 	
 	if (count == 0)
@@ -222,6 +222,6 @@
 void bitmap_copy(bitmap_t *dst, bitmap_t *src, size_t count)
 {
-	ASSERT(count <= dst->elements);
-	ASSERT(count <= src->elements);
+	assert(count <= dst->elements);
+	assert(count <= src->elements);
 	
 	size_t i;
Index: kernel/generic/src/adt/btree.c
===================================================================
--- kernel/generic/src/adt/btree.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/adt/btree.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -49,6 +49,6 @@
 #include <adt/btree.h>
 #include <adt/list.h>
+#include <assert.h>
 #include <mm/slab.h>
-#include <debug.h>
 #include <panic.h>
 #include <print.h>
@@ -500,6 +500,6 @@
 	size_t j;
 	
-	ASSERT(median);
-	ASSERT(node->keys == BTREE_MAX_KEYS);
+	assert(median);
+	assert(node->keys == BTREE_MAX_KEYS);
 	
 	/*
@@ -625,5 +625,5 @@
 	btree_node_t *lnode;
 	
-	ASSERT(value);
+	assert(value);
 	
 	lnode = leaf_node;
@@ -725,5 +725,5 @@
 	size_t i;
 	
-	ASSERT(!ROOT_NODE(node));
+	assert(!ROOT_NODE(node));
 	
 	idx = find_key_by_subtree(node->parent, node, false);
@@ -837,5 +837,5 @@
 		
 		idx = find_key_by_subtree(parent, rnode, true);
-		ASSERT((int) idx != -1);
+		assert((int) idx != -1);
 		slab_free(btree_node_slab, rnode);
 		_btree_remove(t, parent->key[idx], parent);
@@ -951,5 +951,5 @@
 btree_node_t *btree_leaf_node_left_neighbour(btree_t *t, btree_node_t *node)
 {
-	ASSERT(LEAF_NODE(node));
+	assert(LEAF_NODE(node));
 	
 	if (node->leaf_link.prev != &t->leaf_list.head)
@@ -970,5 +970,5 @@
 btree_node_t *btree_leaf_node_right_neighbour(btree_t *t, btree_node_t *node)
 {
-	ASSERT(LEAF_NODE(node));
+	assert(LEAF_NODE(node));
 	
 	if (node->leaf_link.next != &t->leaf_list.head)
@@ -1002,9 +1002,9 @@
 		
 		hlp = list_first(&list);
-		ASSERT(hlp != NULL);
+		assert(hlp != NULL);
 		node = list_get_instance(hlp, btree_node_t, bfs_link);
 		list_remove(hlp);
 		
-		ASSERT(node);
+		assert(node);
 		
 		if (node->depth != depth) {
@@ -1032,5 +1032,5 @@
 	printf("Printing list of leaves:\n");
 	list_foreach(t->leaf_list, leaf_link, btree_node_t, node) {
-		ASSERT(node);
+		assert(node);
 		
 		printf("(");
Index: kernel/generic/src/adt/cht.c
===================================================================
--- kernel/generic/src/adt/cht.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/adt/cht.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -290,5 +290,5 @@
 #include <adt/cht.h>
 #include <adt/hash.h>
-#include <debug.h>
+#include <assert.h>
 #include <mm/slab.h>
 #include <arch/barrier.h>
@@ -522,9 +522,9 @@
 	bool can_block, cht_ops_t *op)
 {
-	ASSERT(h);
-	ASSERT(op && op->hash && op->key_hash && op->equal && op->key_equal);
+	assert(h);
+	assert(op && op->hash && op->key_hash && op->equal && op->key_equal);
 	/* Memoized hashes are stored in the rcu_link.func function pointer. */
-	STATIC_ASSERT(sizeof(size_t) == sizeof(rcu_func_t));
-	ASSERT(sentinel.hash == (uintptr_t)sentinel.rcu_link.func);
+	static_assert(sizeof(size_t) == sizeof(rcu_func_t), "");
+	assert(sentinel.hash == (uintptr_t)sentinel.rcu_link.func);
 
 	/* All operations are compulsory. */
@@ -625,5 +625,5 @@
 	
 	/* You must clear the table of items. Otherwise cht_destroy will leak. */
-	ASSERT(atomic_get(&h->item_cnt) == 0);
+	assert(atomic_get(&h->item_cnt) == 0);
 }
 
@@ -685,7 +685,7 @@
 static inline cht_link_t *find_lazy(cht_t *h, void *key)
 {
-	ASSERT(h);
+	assert(h);
 	/* See docs to cht_find() and cht_find_lazy(). */
-	ASSERT(rcu_read_locked());
+	assert(rcu_read_locked());
 	
 	size_t hash = calc_key_hash(h, key);
@@ -731,7 +731,7 @@
 cht_link_t *cht_find_next_lazy(cht_t *h, const cht_link_t *item)
 {
-	ASSERT(h);
-	ASSERT(rcu_read_locked());
-	ASSERT(item);
+	assert(h);
+	assert(rcu_read_locked());
+	assert(item);
 	
 	return find_duplicate(h, item, calc_node_hash(h, item), get_next(item->link));
@@ -755,5 +755,5 @@
 	do {
 		cur = get_next(prev);
-		ASSERT(cur);
+		assert(cur);
 		prev = cur->link;
 	} while (node_hash(h, cur) < search_hash);
@@ -770,5 +770,5 @@
 		
 		cur = get_next(cur->link);
-		ASSERT(cur);
+		assert(cur);
 	} 
 	
@@ -790,6 +790,6 @@
 	marked_ptr_t old_head, size_t old_idx)
 {
-	ASSERT(N_INVALID == get_mark(old_head)); 
-	ASSERT(h->new_b);
+	assert(N_INVALID == get_mark(old_head)); 
+	assert(h->new_b);
 	
 	size_t new_idx = calc_bucket_idx(hash, h->new_b->order);
@@ -903,5 +903,5 @@
 			 * traversing search_head.
 			 */
-			ASSERT(N_JOIN & get_mark(get_next(old_head)->link));
+			assert(N_JOIN & get_mark(get_next(old_head)->link));
 			return search_bucket(h, old_head, key, hash);
 		}
@@ -913,10 +913,10 @@
 		 * sure all cpus see that the new table replaced the old one.
 		 */
-		ASSERT(h->b->order == h->new_b->order);
+		assert(h->b->order == h->new_b->order);
 		/* 
 		 * The resizer must ensure all new bucket heads are visible before
 		 * replacing the old table.
 		 */
-		ASSERT(N_NORMAL == get_mark(new_head));
+		assert(N_NORMAL == get_mark(new_head));
 		return search_bucket(h, new_head, key, hash);
 	}
@@ -961,6 +961,6 @@
 bool cht_insert_unique(cht_t *h, cht_link_t *item, cht_link_t **dup_item)
 {
-	ASSERT(rcu_read_locked());
-	ASSERT(dup_item);
+	assert(rcu_read_locked());
+	assert(dup_item);
 	return insert_impl(h, item, dup_item);
 }
@@ -1060,5 +1060,5 @@
 		return ret == make_link(wnd->cur, jf_mark);
 	} else {
-		ASSERT(walk_mode == WM_LEAVE_JOIN);
+		assert(walk_mode == WM_LEAVE_JOIN);
 
 		item->link = make_link(wnd->cur, N_NORMAL);
@@ -1087,6 +1087,6 @@
 	cht_link_t *cur, cht_link_t **dup_item)
 {
-	ASSERT(cur);
-	ASSERT(cur == &sentinel || hash <= node_hash(h, cur)
+	assert(cur);
+	assert(cur == &sentinel || hash <= node_hash(h, cur)
 		|| node_hash(h, cur) == h->invalid_hash);
 	
@@ -1110,13 +1110,13 @@
 	cht_link_t *start)
 {
-	ASSERT(hash <= node_hash(h, start) || h->invalid_hash == node_hash(h, start));
+	assert(hash <= node_hash(h, start) || h->invalid_hash == node_hash(h, start));
 
 	cht_link_t *cur = start;
 	
 try_again:	
-	ASSERT(cur);
+	assert(cur);
 
 	while (node_hash(h, cur) == hash) {
-		ASSERT(cur != &sentinel);
+		assert(cur != &sentinel);
 		
 		bool deleted = (N_DELETED & get_mark(cur->link));
@@ -1127,5 +1127,5 @@
 		
 		cur = get_next(cur->link);
-		ASSERT(cur);
+		assert(cur);
 	} 
 
@@ -1142,5 +1142,5 @@
 size_t cht_remove_key(cht_t *h, void *key)
 {
-	ASSERT(h);
+	assert(h);
 	
 	size_t hash = calc_key_hash(h, key);
@@ -1163,8 +1163,8 @@
 bool cht_remove_item(cht_t *h, cht_link_t *item)
 {
-	ASSERT(h);
-	ASSERT(item);
+	assert(h);
+	assert(item);
 	/* Otherwise a concurrent cht_remove_key might free the item. */
-	ASSERT(rcu_read_locked());
+	assert(rcu_read_locked());
 
 	/* 
@@ -1262,5 +1262,5 @@
 	bool *deleted_but_gc, bool *resizing)
 {
-	ASSERT(wnd->cur && wnd->cur != &sentinel);
+	assert(wnd->cur && wnd->cur != &sentinel);
 	
 	*deleted_but_gc = false;
@@ -1292,5 +1292,5 @@
 	bool *resizing)
 {
-	ASSERT(cur && cur != &sentinel);
+	assert(cur && cur != &sentinel);
 	
 	/* 
@@ -1310,5 +1310,5 @@
 		}
 	} else {
-		STATIC_ASSERT(N_JOIN == N_JOIN_FOLLOWS);
+		static_assert(N_JOIN == N_JOIN_FOLLOWS, "");
 		
 		/* Keep the N_JOIN/N_JOIN_FOLLOWS mark but strip N_DELETED. */
@@ -1329,6 +1329,6 @@
 	bool *resizing)
 {
-	ASSERT(wnd->cur != &sentinel);
-	ASSERT(wnd->cur && (N_DELETED & get_mark(wnd->cur->link)));
+	assert(wnd->cur != &sentinel);
+	assert(wnd->cur && (N_DELETED & get_mark(wnd->cur->link)));
 	
 	cht_link_t *next = get_next(wnd->cur->link);
@@ -1336,5 +1336,5 @@
 	if (walk_mode == WM_LEAVE_JOIN) {
 		/* Never try to unlink join nodes. */
-		ASSERT(!(N_JOIN & get_mark(wnd->cur->link)));
+		assert(!(N_JOIN & get_mark(wnd->cur->link)));
 
 		mark_t pred_mark = get_mark(*wnd->ppred);
@@ -1348,5 +1348,5 @@
 			return false;
 	} else {
-		ASSERT(walk_mode == WM_MOVE_JOIN_FOLLOWS || walk_mode == WM_NORMAL);
+		assert(walk_mode == WM_MOVE_JOIN_FOLLOWS || walk_mode == WM_NORMAL);
 		/* Move the JF mark if set. Clear DEL mark. */
 		mark_t cur_mark = N_JOIN_FOLLOWS & get_mark(wnd->cur->link);
@@ -1398,5 +1398,5 @@
 	equal_pred_t pred, void *pred_arg, wnd_t *wnd, bool *resizing)
 {
-	ASSERT(wnd->cur);
+	assert(wnd->cur);
 	
 	if (wnd->cur == &sentinel)
@@ -1415,5 +1415,5 @@
 		
 	while (cur_hash <= hash) {
-		ASSERT(wnd->cur && wnd->cur != &sentinel);
+		assert(wnd->cur && wnd->cur != &sentinel);
 		
 		/* GC any deleted nodes on the way. */
@@ -1436,5 +1436,5 @@
 	if (cur_hash == h->invalid_hash) {
 		next_wnd(wnd);
-		ASSERT(wnd->cur);
+		assert(wnd->cur);
 		goto try_again;
 	}
@@ -1469,5 +1469,5 @@
 {
 try_again:
-	ASSERT(wnd->cur);
+	assert(wnd->cur);
 
 	while (node_hash(h, wnd->cur) < hash) {
@@ -1482,5 +1482,5 @@
 		}
 		
-		ASSERT(wnd->cur);
+		assert(wnd->cur);
 	}
 	
@@ -1498,5 +1498,5 @@
 	bool *resizing)
 {
-	ASSERT(N_DELETED & get_mark(wnd->cur->link));
+	assert(N_DELETED & get_mark(wnd->cur->link));
 
 	/* Skip deleted JOIN nodes. */
@@ -1505,5 +1505,5 @@
 	} else {
 		/* Ordinary deleted node or a deleted JOIN_FOLLOWS. */
-		ASSERT(walk_mode != WM_LEAVE_JOIN 
+		assert(walk_mode != WM_LEAVE_JOIN 
 			|| !((N_JOIN | N_JOIN_FOLLOWS) & get_mark(wnd->cur->link)));
 
@@ -1546,6 +1546,6 @@
 	 * it 
 	 */
-	ASSERT(h->b->order > h->new_b->order);
-	ASSERT(wnd->cur);
+	assert(h->b->order > h->new_b->order);
+	assert(wnd->cur);
 	
 	/* Either we did not need the joining link or we have already followed it.*/
@@ -1620,13 +1620,13 @@
 		/* The hash belongs to the moved bucket. */
 		if (move_dest_idx == new_idx) {
-			ASSERT(pmoved_head == pnew_head);
+			assert(pmoved_head == pnew_head);
 			/* 
 			 * move_head() makes the new head of the moved bucket visible. 
 			 * The new head may be marked with a JOIN_FOLLOWS
 			 */
-			ASSERT(!(N_CONST & get_mark(*pmoved_head)));
+			assert(!(N_CONST & get_mark(*pmoved_head)));
 			*walk_mode = WM_MOVE_JOIN_FOLLOWS;
 		} else {
-			ASSERT(pmoved_head != pnew_head);
+			assert(pmoved_head != pnew_head);
 			/* 
 			 * The hash belongs to the bucket that is the result of splitting 
@@ -1643,5 +1643,5 @@
 				 * JOIN_FOLLOWS in this part of split bucket.
 				 */
-				ASSERT(N_NORMAL == get_mark(*pnew_head));
+				assert(N_NORMAL == get_mark(*pnew_head));
 			}
 			
@@ -1675,7 +1675,7 @@
 		
 		/* move_head() or join_buckets() makes it so or makes the mark visible.*/
-		ASSERT(N_INVALID == get_mark(*pold_head));
+		assert(N_INVALID == get_mark(*pold_head));
 		/* move_head() makes it visible. No JOIN_FOLLOWS used when shrinking. */
-		ASSERT(N_NORMAL == get_mark(*pnew_head));
+		assert(N_NORMAL == get_mark(*pnew_head));
 
 		*walk_mode = WM_LEAVE_JOIN;
@@ -1685,5 +1685,5 @@
 		 * readers to notice that the old table had been replaced.
 		 */
-		ASSERT(b == h->new_b);
+		assert(b == h->new_b);
 		*walk_mode = WM_NORMAL;
 	}
@@ -1712,5 +1712,5 @@
 {
 	/* Head move has to in progress already when calling this func. */
-	ASSERT(N_CONST & get_mark(*psrc_head));
+	assert(N_CONST & get_mark(*psrc_head));
 	
 	/* Head already moved. */
@@ -1725,5 +1725,5 @@
 	}
 	
-	ASSERT(!(N_CONST & get_mark(*pdest_head)));
+	assert(!(N_CONST & get_mark(*pdest_head)));
 }
 
@@ -1756,6 +1756,6 @@
 static void complete_head_move(marked_ptr_t *psrc_head, marked_ptr_t *pdest_head)
 {
-	ASSERT(N_JOIN_FOLLOWS != get_mark(*psrc_head));
-	ASSERT(N_CONST & get_mark(*psrc_head));
+	assert(N_JOIN_FOLLOWS != get_mark(*psrc_head));
+	assert(N_CONST & get_mark(*psrc_head));
 	
 	cht_link_t *next = get_next(*psrc_head);
@@ -1763,10 +1763,10 @@
 	DBG(marked_ptr_t ret = )
 		cas_link(pdest_head, &sentinel, N_INVALID, next, N_NORMAL);
-	ASSERT(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
+	assert(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
 	cas_order_barrier();
 	
 	DBG(ret = ) 
 		cas_link(psrc_head, next, N_CONST, next, N_INVALID);	
-	ASSERT(ret == make_link(next, N_CONST) || (N_INVALID == get_mark(ret)));
+	assert(ret == make_link(next, N_CONST) || (N_INVALID == get_mark(ret)));
 	cas_order_barrier();
 }
@@ -1861,5 +1861,5 @@
 	DBG(marked_ptr_t ret = )
 		cas_link(pdest_head, &sentinel, N_INVALID, wnd.cur, N_NORMAL);
-	ASSERT(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
+	assert(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
 	cas_order_barrier();
 	
@@ -1905,5 +1905,5 @@
 		
 		/* Must not report that the table is resizing if WM_MOVE_JOIN_FOLLOWS.*/
-		ASSERT(!resizing);
+		assert(!resizing);
 		/* 
 		 * Mark the last node of the first half of the split bucket 
@@ -2042,5 +2042,5 @@
 	DBG(marked_ptr_t ret = )
 		cas_link(psrc_head, join_node, N_CONST, join_node, N_INVALID);
-	ASSERT(ret == make_link(join_node, N_CONST) || (N_INVALID == get_mark(ret)));
+	assert(ret == make_link(join_node, N_CONST) || (N_INVALID == get_mark(ret)));
 	cas_order_barrier();
 	
@@ -2073,9 +2073,9 @@
 			continue;
 
-		ASSERT(!resizing);
+		assert(!resizing);
 		
 		if (wnd.cur != &sentinel) {
 			/* Must be from the new appended bucket. */
-			ASSERT(split_hash <= node_hash(h, wnd.cur) 
+			assert(split_hash <= node_hash(h, wnd.cur) 
 				|| h->invalid_hash == node_hash(h, wnd.cur));
 			return;
@@ -2096,5 +2096,5 @@
 static void free_later(cht_t *h, cht_link_t *item)
 {
-	ASSERT(item != &sentinel);
+	assert(item != &sentinel);
 	
 	/* 
@@ -2156,8 +2156,8 @@
 	
 #ifdef CONFIG_DEBUG
-	ASSERT(h->b);
+	assert(h->b);
 	/* Make resize_reqs visible. */
 	read_barrier();
-	ASSERT(0 < atomic_get(&h->resize_reqs));
+	assert(0 < atomic_get(&h->resize_reqs));
 #endif
 
@@ -2336,5 +2336,5 @@
 		/* Set the invalid joinee head to NULL. */
 		if (old_idx != move_src_idx) {
-			ASSERT(N_INVALID == get_mark(h->b->head[old_idx]));
+			assert(N_INVALID == get_mark(h->b->head[old_idx]));
 			
 			if (&sentinel != get_next(h->b->head[old_idx]))
@@ -2392,6 +2392,6 @@
 	marked_ptr_t *new_head)
 {
-	ASSERT(join_node != &sentinel);
-	ASSERT(join_node && (N_JOIN & get_mark(join_node->link)));
+	assert(join_node != &sentinel);
+	assert(join_node && (N_JOIN & get_mark(join_node->link)));
 	
 	bool done;
@@ -2409,5 +2409,5 @@
 		/* Done if the mark was cleared. Retry if a new node was inserted. */
 		done = (ret == jn_link);
-		ASSERT(ret == jn_link || (get_mark(ret) & N_JOIN));
+		assert(ret == jn_link || (get_mark(ret) & N_JOIN));
 	} while (!done);
 	
@@ -2432,5 +2432,5 @@
 			join_node, &wnd, &resizing);
 		
-		ASSERT(!resizing);
+		assert(!resizing);
 	} while (!done);
 }
@@ -2439,5 +2439,5 @@
 static void cleanup_join_follows(cht_t *h, marked_ptr_t *new_head)
 {
-	ASSERT(new_head);
+	assert(new_head);
 	
 	rcu_read_lock();
@@ -2464,7 +2464,7 @@
 		/* GC any deleted nodes on the way - even deleted JOIN_FOLLOWS. */
 		if (N_DELETED & get_mark(*cur_link)) {
-			ASSERT(cur_link != new_head);
-			ASSERT(wnd.ppred && wnd.cur && wnd.cur != &sentinel);
-			ASSERT(cur_link == &wnd.cur->link);
+			assert(cur_link != new_head);
+			assert(wnd.ppred && wnd.cur && wnd.cur != &sentinel);
+			assert(cur_link == &wnd.cur->link);
 
 			bool dummy;
@@ -2484,5 +2484,5 @@
 					cas_link(cur_link, next, N_JOIN_FOLLOWS, &sentinel, N_NORMAL);
 				
-				ASSERT(next == &sentinel 
+				assert(next == &sentinel 
 					|| ((N_JOIN | N_JOIN_FOLLOWS) & get_mark(ret)));
 
@@ -2505,5 +2505,5 @@
 
 		/* We must encounter a JF node before we reach the end of the bucket. */
-		ASSERT(wnd.cur && wnd.cur != &sentinel);
+		assert(wnd.cur && wnd.cur != &sentinel);
 		cur_link = &wnd.cur->link;
 	}
@@ -2519,5 +2519,5 @@
 static inline size_t calc_split_hash(size_t split_idx, size_t order)
 {
-	ASSERT(1 <= order && order <= 8 * sizeof(size_t));
+	assert(1 <= order && order <= 8 * sizeof(size_t));
 	return split_idx << (8 * sizeof(size_t) - order);
 }
@@ -2526,5 +2526,5 @@
 static inline size_t calc_bucket_idx(size_t hash, size_t order)
 {
-	ASSERT(1 <= order && order <= 8 * sizeof(size_t));
+	assert(1 <= order && order <= 8 * sizeof(size_t));
 	return hash >> (8 * sizeof(size_t) - order);
 }
@@ -2558,5 +2558,5 @@
 static inline size_t node_hash(cht_t *h, const cht_link_t *item)
 {
-	ASSERT(item->hash == h->invalid_hash 
+	assert(item->hash == h->invalid_hash 
 		|| item->hash == sentinel.hash
 		|| item->hash == calc_node_hash(h, item));
@@ -2568,5 +2568,5 @@
 static inline size_t calc_node_hash(cht_t *h, const cht_link_t *item)
 {
-	ASSERT(item != &sentinel);
+	assert(item != &sentinel);
 	/* 
 	 * Clear the lowest order bit in order for sentinel's node hash
@@ -2587,6 +2587,6 @@
 	marked_ptr_t ptr = (marked_ptr_t) next;
 	
-	ASSERT(!(ptr & N_MARK_MASK));
-	ASSERT(!((unsigned)mark & ~N_MARK_MASK));
+	assert(!(ptr & N_MARK_MASK));
+	assert(!((unsigned)mark & ~N_MARK_MASK));
 	
 	return ptr | mark;
@@ -2608,6 +2608,6 @@
 static inline void next_wnd(wnd_t *wnd)
 {
-	ASSERT(wnd);
-	ASSERT(wnd->cur);
+	assert(wnd);
+	assert(wnd->cur);
 
 	wnd->last = wnd->cur;
@@ -2635,5 +2635,5 @@
 	marked_ptr_t new)
 {
-	ASSERT(link != &sentinel.link);
+	assert(link != &sentinel.link);
 	/*
 	 * cas(x) on the same location x on one cpu must be ordered, but do not
Index: kernel/generic/src/adt/hash_table.c
===================================================================
--- kernel/generic/src/adt/hash_table.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/adt/hash_table.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -40,6 +40,6 @@
 #include <adt/hash_table.h>
 #include <adt/list.h>
+#include <assert.h>
 #include <typedefs.h>
-#include <debug.h>
 #include <mm/slab.h>
 #include <mem.h>
@@ -56,9 +56,9 @@
 	size_t i;
 
-	ASSERT(h);
-	ASSERT(op);
-	ASSERT(op->hash);
-	ASSERT(op->compare);
-	ASSERT(max_keys > 0);
+	assert(h);
+	assert(op);
+	assert(op->hash);
+	assert(op->compare);
+	assert(max_keys > 0);
 	
 	h->entry = (list_t *) malloc(m * sizeof(list_t), 0);
@@ -86,12 +86,12 @@
 	size_t chain;
 	
-	ASSERT(item);
-	ASSERT(h);
-	ASSERT(h->op);
-	ASSERT(h->op->hash);
-	ASSERT(h->op->compare);
+	assert(item);
+	assert(h);
+	assert(h->op);
+	assert(h->op->hash);
+	assert(h->op->compare);
 	
 	chain = h->op->hash(key);
-	ASSERT(chain < h->entries);
+	assert(chain < h->entries);
 	
 	list_append(item, &h->entry[chain]);
@@ -109,11 +109,11 @@
 	size_t chain;
 	
-	ASSERT(h);
-	ASSERT(h->op);
-	ASSERT(h->op->hash);
-	ASSERT(h->op->compare);
+	assert(h);
+	assert(h->op);
+	assert(h->op->hash);
+	assert(h->op->compare);
 	
 	chain = h->op->hash(key);
-	ASSERT(chain < h->entries);
+	assert(chain < h->entries);
 	
 	link_t *cur = list_first(&h->entry[chain]);
@@ -143,9 +143,9 @@
 	size_t chain;
 	
-	ASSERT(h);
-	ASSERT(h->op);
-	ASSERT(h->op->hash);
-	ASSERT(h->op->compare);
-	ASSERT(keys <= h->max_keys);
+	assert(h);
+	assert(h->op);
+	assert(h->op->hash);
+	assert(h->op->compare);
+	assert(keys <= h->max_keys);
 	
 	
Index: kernel/generic/src/console/chardev.c
===================================================================
--- kernel/generic/src/console/chardev.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/console/chardev.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -33,4 +33,5 @@
  */
 
+#include <assert.h>
 #include <adt/list.h>
 #include <console/chardev.h>
@@ -66,5 +67,5 @@
 void indev_push_character(indev_t *indev, wchar_t ch)
 {
-	ASSERT(indev);
+	assert(indev);
 	
 	irq_spinlock_lock(&indev->lock, true);
Index: kernel/generic/src/console/cmd.c
===================================================================
--- kernel/generic/src/console/cmd.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/console/cmd.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -41,4 +41,5 @@
  */
 
+#include <assert.h>
 #include <console/cmd.h>
 #include <console/console.h>
@@ -54,5 +55,4 @@
 #include <str.h>
 #include <macros.h>
-#include <debug.h>
 #include <cpu.h>
 #include <mm/tlb.h>
@@ -917,5 +917,5 @@
 int cmd_uptime(cmd_arg_t *argv)
 {
-	ASSERT(uptime);
+	assert(uptime);
 	
 	/* This doesn't have to be very accurate */
Index: kernel/generic/src/console/console.c
===================================================================
--- kernel/generic/src/console/console.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/console/console.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
  */
 
+#include <assert.h>
 #include <console/console.h>
 #include <console/chardev.h>
@@ -189,5 +190,5 @@
 	void *faddr = (void *) KA2PA(kio);
 	
-	ASSERT((uintptr_t) faddr % FRAME_SIZE == 0);
+	assert((uintptr_t) faddr % FRAME_SIZE == 0);
 	
 	kio_parea.pbase = (uintptr_t) faddr;
Index: kernel/generic/src/console/kconsole.c
===================================================================
--- kernel/generic/src/console/kconsole.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/console/kconsole.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,4 +39,5 @@
  */
 
+#include <assert.h>
 #include <console/kconsole.h>
 #include <console/console.h>
@@ -633,6 +634,6 @@
     size_t *start, size_t *end)
 {
-	ASSERT(start != NULL);
-	ASSERT(end != NULL);
+	assert(start != NULL);
+	assert(end != NULL);
 	
 	bool found_start = false;
Index: kernel/generic/src/console/prompt.c
===================================================================
--- kernel/generic/src/console/prompt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/console/prompt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,4 +37,5 @@
  */
 
+#include <assert.h>
 #include <console/prompt.h>
 
@@ -49,6 +50,6 @@
 bool console_prompt_display_all_hints(indev_t *indev, size_t hints)
 {
-	ASSERT(indev);
-	ASSERT(hints > 0);
+	assert(indev);
+	assert(hints > 0);
 	
 	printf("Display all %zu possibilities? (y or n) ", hints);
@@ -81,6 +82,6 @@
 bool console_prompt_more_hints(indev_t *indev, size_t *display_hints)
 {
-	ASSERT(indev);
-	ASSERT(display_hints != NULL);
+	assert(indev);
+	assert(display_hints != NULL);
 	
 	printf("--More--");
Index: kernel/generic/src/cpu/cpu_mask.c
===================================================================
--- kernel/generic/src/cpu/cpu_mask.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/cpu/cpu_mask.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  * @brief CPU mask manipulation functions.
  */
+#include <assert.h>
 #include <cpu/cpu_mask.h>
 #include <cpu.h>
@@ -52,6 +53,6 @@
 static void cpu_mask_count(cpu_mask_t *cpus, size_t cpu_cnt)
 {
-	ASSERT(NULL != cpus);
-	ASSERT(cpu_cnt <= config.cpu_count);
+	assert(NULL != cpus);
+	assert(cpu_cnt <= config.cpu_count);
 	
 	for (size_t active_word = 0; 
@@ -87,5 +88,5 @@
 void cpu_mask_none(cpu_mask_t *cpus)
 {
-	ASSERT(cpus);
+	assert(cpus);
 	
 	size_t word_cnt = cpu_mask_size() / word_size;
Index: kernel/generic/src/ddi/ddi.c
===================================================================
--- kernel/generic/src/ddi/ddi.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ddi/ddi.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -40,4 +40,5 @@
  */
 
+#include <assert.h>
 #include <ddi/ddi.h>
 #include <proc/task.h>
@@ -106,5 +107,5 @@
     unsigned int flags, uintptr_t *virt, uintptr_t bound)
 {
-	ASSERT(TASK);
+	assert(TASK);
 	
 	if ((phys % FRAME_SIZE) != 0)
@@ -211,5 +212,5 @@
 NO_TRACE static int physmem_unmap(uintptr_t virt)
 {
-	ASSERT(TASK);
+	assert(TASK);
 
 	return as_area_destroy(TASK->as, virt);
@@ -368,5 +369,5 @@
     unsigned int flags, uintptr_t *phys)
 {
-	ASSERT(TASK);
+	assert(TASK);
 	
 	// TODO: implement locking of non-anonymous mapping
@@ -378,5 +379,5 @@
     uintptr_t *virt, uintptr_t bound)
 {
-	ASSERT(TASK);
+	assert(TASK);
 	
 	size_t frames = SIZE2FRAMES(size);
Index: kernel/generic/src/ddi/device.c
===================================================================
--- kernel/generic/src/ddi/device.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ddi/device.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <typedefs.h>
 #include <ddi/device.h>
@@ -49,5 +50,5 @@
 {
 	devno_t devno = (devno_t) atomic_postinc(&last);
-	ASSERT(devno >= 0);
+	assert(devno >= 0);
 	
 	return devno;
Index: kernel/generic/src/interrupt/interrupt.c
===================================================================
--- kernel/generic/src/interrupt/interrupt.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/interrupt/interrupt.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -40,6 +40,6 @@
  */
 
+#include <assert.h>
 #include <interrupt.h>
-#include <debug.h>
 #include <console/kconsole.h>
 #include <console/console.h>
@@ -76,5 +76,5 @@
 {
 #if (IVT_ITEMS > 0)
-	ASSERT(n < IVT_ITEMS);
+	assert(n < IVT_ITEMS);
 #endif
 	
@@ -102,5 +102,5 @@
 {
 #if (IVT_ITEMS > 0)
-	ASSERT(n < IVT_ITEMS);
+	assert(n < IVT_ITEMS);
 #endif
 	
Index: kernel/generic/src/ipc/event.c
===================================================================
--- kernel/generic/src/ipc/event.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/event.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -35,4 +35,5 @@
  */
 
+#include <assert.h>
 #include <ipc/event.h>
 #include <mm/slab.h>
@@ -59,5 +60,5 @@
 static event_t *evno2event(int evno, task_t *task)
 {
-	ASSERT(evno < EVENT_TASK_END);
+	assert(evno < EVENT_TASK_END);
 	
 	event_t *event;
@@ -123,5 +124,5 @@
 void event_set_unmask_callback(event_type_t evno, event_callback_t callback)
 {
-	ASSERT(evno < EVENT_END);
+	assert(evno < EVENT_END);
 	
 	_event_set_unmask_callback(evno2event(evno, NULL), callback);
@@ -131,6 +132,6 @@
     event_callback_t callback)
 {
-	ASSERT(evno >= (int) EVENT_END);
-	ASSERT(evno < EVENT_TASK_END);
+	assert(evno >= (int) EVENT_END);
+	assert(evno < EVENT_TASK_END);
 		
 	_event_set_unmask_callback(evno2event(evno, task), callback);
@@ -208,5 +209,5 @@
     sysarg_t a3, sysarg_t a4, sysarg_t a5)
 {
-	ASSERT(evno < EVENT_END);
+	assert(evno < EVENT_END);
 	
 	return event_enqueue(evno2event(evno, NULL), mask, a1, a2, a3, a4, a5);
@@ -236,6 +237,6 @@
     sysarg_t a1, sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
 {
-	ASSERT(evno >= (int) EVENT_END);
-	ASSERT(evno < EVENT_TASK_END);
+	assert(evno >= (int) EVENT_END);
+	assert(evno < EVENT_TASK_END);
 	
 	return event_enqueue(evno2event(evno, task), mask, a1, a2, a3, a4, a5);
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/ipc.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
  */
 
+#include <assert.h>
 #include <synch/spinlock.h>
 #include <synch/mutex.h>
@@ -52,5 +53,4 @@
 #include <proc/task.h>
 #include <mem.h>
-#include <debug.h>
 #include <print.h>
 #include <console/console.h>
@@ -227,5 +227,5 @@
 		spinlock_lock(&TASK->active_calls_lock);
 
-		ASSERT(!request->forget);
+		assert(!request->forget);
 
 		bool answered = !request->active;
@@ -253,5 +253,5 @@
 		}
 	}
-	ASSERT(!answer || request == answer);
+	assert(!answer || request == answer);
 	
 	slab_free(ipc_answerbox_slab, mybox);
@@ -631,5 +631,5 @@
 		
 		/* Disconnect phone */
-		ASSERT(phone->state == IPC_PHONE_CONNECTED);
+		assert(phone->state == IPC_PHONE_CONNECTED);
 		
 		list_remove(&phone->link);
@@ -668,6 +668,6 @@
 static void ipc_forget_call(call_t *call)
 {
-	ASSERT(spinlock_locked(&TASK->active_calls_lock));
-	ASSERT(spinlock_locked(&call->forget_lock));
+	assert(spinlock_locked(&TASK->active_calls_lock));
+	assert(spinlock_locked(&call->forget_lock));
 
 	/*
@@ -789,5 +789,5 @@
 	call = ipc_wait_for_call(&TASK->answerbox, SYNCH_NO_TIMEOUT,
 	    SYNCH_FLAGS_NONE);
-	ASSERT(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF));
+	assert(call->flags & (IPC_CALL_ANSWERED | IPC_CALL_NOTIF));
 
 	SYSIPC_OP(answer_process, call);
Index: kernel/generic/src/ipc/ipcrsc.c
===================================================================
--- kernel/generic/src/ipc/ipcrsc.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/ipcrsc.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -131,5 +131,5 @@
 #include <proc/task.h>
 #include <ipc/ipcrsc.h>
-#include <debug.h>
+#include <assert.h>
 #include <abi/errno.h>
 
@@ -220,5 +220,5 @@
 static void phone_deallocp(phone_t *phone)
 {
-	ASSERT(phone->state == IPC_PHONE_CONNECTING);
+	assert(phone->state == IPC_PHONE_CONNECTING);
 	
 	/* Atomic operation */
@@ -253,5 +253,5 @@
 	phone_t *phone = &TASK->phones[phoneid];
 	
-	ASSERT(phone->state == IPC_PHONE_CONNECTING);
+	assert(phone->state == IPC_PHONE_CONNECTING);
 	return ipc_phone_connect(phone, box);
 }
Index: kernel/generic/src/ipc/irq.c
===================================================================
--- kernel/generic/src/ipc/irq.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/irq.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -72,4 +72,5 @@
 
 #include <arch.h>
+#include <assert.h>
 #include <mm/slab.h>
 #include <mm/page.h>
@@ -399,5 +400,5 @@
 	irq_spinlock_lock(&box->irq_lock, false);
 	
-	ASSERT(irq->notif_cfg.answerbox == box);
+	assert(irq->notif_cfg.answerbox == box);
 	
 	/* Remove the IRQ from the answerbox's list. */
@@ -463,5 +464,5 @@
 		key[1] = irq->devno;
 		
-		ASSERT(irq->notif_cfg.answerbox == box);
+		assert(irq->notif_cfg.answerbox == box);
 		
 		/* Unlist from the answerbox. */
@@ -607,8 +608,8 @@
 void ipc_irq_top_half_handler(irq_t *irq)
 {
-	ASSERT(irq);
-	
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&irq->lock));
+	assert(irq);
+	
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&irq->lock));
 	
 	if (irq->notif_cfg.answerbox) {
Index: kernel/generic/src/ipc/ops/dataread.c
===================================================================
--- kernel/generic/src/ipc/ops/dataread.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/ops/dataread.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -33,4 +33,5 @@
  */
 
+#include <assert.h>
 #include <ipc/sysipc_ops.h>
 #include <ipc/ipc.h>
@@ -58,5 +59,5 @@
 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-	ASSERT(!answer->buffer);
+	assert(!answer->buffer);
 
 	if (!IPC_GET_RETVAL(answer->data)) {
Index: kernel/generic/src/ipc/ops/datawrite.c
===================================================================
--- kernel/generic/src/ipc/ops/datawrite.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/ops/datawrite.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -33,4 +33,5 @@
  */
 
+#include <assert.h>
 #include <ipc/sysipc_ops.h>
 #include <ipc/ipc.h>
@@ -70,5 +71,5 @@
 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-	ASSERT(answer->buffer);
+	assert(answer->buffer);
 
 	if (!IPC_GET_RETVAL(answer->data)) {
Index: kernel/generic/src/ipc/sysipc.c
===================================================================
--- kernel/generic/src/ipc/sysipc.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/ipc/sysipc.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
 
 #include <arch.h>
+#include <assert.h>
 #include <errno.h>
 #include <mem.h>
@@ -174,5 +175,5 @@
 		return rc;
 	} else {
-		ASSERT(answer->active);
+		assert(answer->active);
 
 		/*
@@ -313,5 +314,5 @@
 				 * We are no longer expected to free it.
 				 */
-				ASSERT(rc == EINTR);
+				assert(rc == EINTR);
 			}
 			return rc;	
Index: kernel/generic/src/lib/elf.c
===================================================================
--- kernel/generic/src/lib/elf.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/lib/elf.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,6 +37,6 @@
  */
 
+#include <assert.h>
 #include <lib/elf.h>
-#include <debug.h>
 #include <typedefs.h>
 #include <mm/as.h>
@@ -138,5 +138,5 @@
 const char *elf_error(unsigned int rc)
 {
-	ASSERT(rc < sizeof(error_codes) / sizeof(char *));
+	assert(rc < sizeof(error_codes) / sizeof(char *));
 	
 	return error_codes[rc];
Index: kernel/generic/src/lib/ra.c
===================================================================
--- kernel/generic/src/lib/ra.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/lib/ra.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -43,9 +43,9 @@
  */
 
+#include <assert.h>
 #include <lib/ra.h>
 #include <typedefs.h>
 #include <mm/slab.h>
 #include <bitops.h>
-#include <debug.h>
 #include <panic.h>
 #include <adt/list.h>
@@ -241,5 +241,5 @@
 		    ra_segment_t, fu_link);
 
-		ASSERT(seg->flags & RA_SEGMENT_FREE);
+		assert(seg->flags & RA_SEGMENT_FREE);
 
 		/*
@@ -259,5 +259,5 @@
 		newbase = ALIGN_UP(seg->base, align);
 		if (newbase + size != seg->base + ra_segment_size_get(seg)) {
-			ASSERT(newbase + (size - 1) < seg->base +
+			assert(newbase + (size - 1) < seg->base +
 			    (ra_segment_size_get(seg) - 1));
 			succ = ra_segment_create(newbase + size);
@@ -331,7 +331,7 @@
 	hash_table_remove(&span->used, &key, 1);
 
-	ASSERT(!(seg->flags & RA_SEGMENT_FREE));
-	ASSERT(seg->base == base);
-	ASSERT(ra_segment_size_get(seg) == size);
+	assert(!(seg->flags & RA_SEGMENT_FREE));
+	assert(seg->base == base);
+	assert(ra_segment_size_get(seg) == size);
 
 	/*
@@ -342,5 +342,5 @@
 		    ra_segment_t, segment_link);
 
-		ASSERT(pred->base < seg->base);
+		assert(pred->base < seg->base);
 
 		if (pred->flags & RA_SEGMENT_FREE) {
@@ -363,5 +363,5 @@
 	succ = hash_table_get_instance(seg->segment_link.next, ra_segment_t,
 	    segment_link);
-	ASSERT(succ->base > seg->base);
+	assert(succ->base > seg->base);
 	if (succ->flags & RA_SEGMENT_FREE) {
 		/*
@@ -386,7 +386,7 @@
 	uintptr_t base = 0;
 
-	ASSERT(size >= 1);
-	ASSERT(alignment >= 1);
-	ASSERT(ispwr2(alignment));
+	assert(size >= 1);
+	assert(alignment >= 1);
+	assert(ispwr2(alignment));
 
 	irq_spinlock_lock(&arena->lock, true);
Index: kernel/generic/src/lib/rd.c
===================================================================
--- kernel/generic/src/lib/rd.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/lib/rd.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
  */
 
+#include <assert.h>
 #include <log.h>
 #include <lib/rd.h>
@@ -56,5 +57,5 @@
 {
 	uintptr_t base = (uintptr_t) data;
-	ASSERT((base % FRAME_SIZE) == 0);
+	assert((base % FRAME_SIZE) == 0);
 	
 	rd_parea.pbase = base;
Index: kernel/generic/src/lib/str.c
===================================================================
--- kernel/generic/src/lib/str.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/lib/str.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -109,5 +109,5 @@
 #include <errno.h>
 #include <align.h>
-#include <debug.h>
+#include <assert.h>
 #include <macros.h>
 #include <mm/slab.h>
@@ -567,6 +567,6 @@
 {
 	/* There must be space for a null terminator in the buffer. */
-	ASSERT(size > 0);
-	ASSERT(src != NULL);
+	assert(size > 0);
+	assert(src != NULL);
 	
 	size_t src_off = 0;
@@ -601,5 +601,5 @@
 {
 	/* There must be space for a null terminator in the buffer. */
-	ASSERT(size > 0);
+	assert(size > 0);
 	
 	size_t src_off = 0;
@@ -635,5 +635,5 @@
 	size_t size = str_size(src) + 1;
 	char *dest = malloc(size, 0);
-	ASSERT(dest);
+	assert(dest);
 	
 	str_cpy(dest, size, src);
@@ -668,5 +668,5 @@
 	
 	char *dest = malloc(size + 1, 0);
-	ASSERT(dest);
+	assert(dest);
 	
 	str_ncpy(dest, size + 1, src, size);
@@ -691,5 +691,5 @@
 
 	/* There must be space for a null terminator in the buffer. */
-	ASSERT(size > 0);
+	assert(size > 0);
 
 	src_idx = 0;
@@ -797,7 +797,7 @@
     bool *neg, uint64_t *result)
 {
-	ASSERT(endptr != NULL);
-	ASSERT(neg != NULL);
-	ASSERT(result != NULL);
+	assert(endptr != NULL);
+	assert(neg != NULL);
+	assert(result != NULL);
 	
 	*neg = false;
@@ -918,5 +918,5 @@
     bool strict, uint64_t *result)
 {
-	ASSERT(result != NULL);
+	assert(result != NULL);
 	
 	bool neg;
Index: kernel/generic/src/main/kinit.c
===================================================================
--- kernel/generic/src/main/kinit.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/main/kinit.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -42,4 +42,5 @@
  */
 
+#include <assert.h>
 #include <main/kinit.h>
 #include <config.h>
@@ -67,5 +68,4 @@
 #include <lib/rd.h>
 #include <ipc/ipc.h>
-#include <debug.h>
 #include <str.h>
 #include <sysinfo/stats.h>
@@ -240,5 +240,5 @@
 			name = "<unknown>";
 		
-		STATIC_ASSERT(TASK_NAME_BUFLEN >= INIT_PREFIX_LEN);
+		static_assert(TASK_NAME_BUFLEN >= INIT_PREFIX_LEN, "");
 		str_cpy(namebuf, TASK_NAME_BUFLEN, INIT_PREFIX);
 		str_cpy(namebuf + INIT_PREFIX_LEN,
@@ -251,5 +251,5 @@
 		    init.tasks[i].size,
 		    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
-		ASSERT(page);
+		assert(page);
 		
 		int rc = program_create_from_image((void *) page, namebuf,
Index: kernel/generic/src/main/main.c
===================================================================
--- kernel/generic/src/main/main.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/main/main.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -48,8 +48,9 @@
 
 #include <arch/asm.h>
+#include <debug.h>
 #include <context.h>
 #include <print.h>
 #include <panic.h>
-#include <debug.h>
+#include <assert.h>
 #include <config.h>
 #include <time/clock.h>
@@ -98,5 +99,5 @@
  */
 #define CHECK_INT_TYPE_(signness, size) \
-	STATIC_ASSERT_VERBOSE(sizeof(signness##size##_t) * 8 == size, \
+	static_assert(sizeof(signness##size##_t) * 8 == size, \
 	    #signness #size "_t does not have " #size " bits");
 
Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/as.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -67,5 +67,5 @@
 #include <arch/asm.h>
 #include <panic.h>
-#include <debug.h>
+#include <assert.h>
 #include <print.h>
 #include <mem.h>
@@ -189,6 +189,6 @@
 	DEADLOCK_PROBE_INIT(p_asidlock);
 	
-	ASSERT(as != AS);
-	ASSERT(atomic_get(&as->refcount) == 0);
+	assert(as != AS);
+	assert(atomic_get(&as->refcount) == 0);
 	
 	/*
@@ -236,5 +236,5 @@
 	bool cond = true;
 	while (cond) {
-		ASSERT(!list_empty(&as->as_area_btree.leaf_list));
+		assert(!list_empty(&as->as_area_btree.leaf_list));
 		
 		btree_node_t *node =
@@ -298,6 +298,6 @@
     size_t count, bool guarded, as_area_t *avoid)
 {
-	ASSERT((addr % PAGE_SIZE) == 0);
-	ASSERT(mutex_locked(&as->lock));
+	assert((addr % PAGE_SIZE) == 0);
+	assert(mutex_locked(&as->lock));
 
 	/*
@@ -455,5 +455,5 @@
     size_t size, bool guarded)
 {
-	ASSERT(mutex_locked(&as->lock));
+	assert(mutex_locked(&as->lock));
 	
 	if (size == 0)
@@ -532,5 +532,5 @@
 	
 	mutex_lock(&sh_info->lock);
-	ASSERT(sh_info->refcount);
+	assert(sh_info->refcount);
 	
 	if (--sh_info->refcount == 0) {
@@ -696,5 +696,5 @@
 NO_TRACE static as_area_t *find_area_and_lock(as_t *as, uintptr_t va)
 {
-	ASSERT(mutex_locked(&as->lock));
+	assert(mutex_locked(&as->lock));
 	
 	btree_node_t *leaf;
@@ -827,5 +827,5 @@
 		bool cond = true;
 		while (cond) {
-			ASSERT(!list_empty(&area->used_space.leaf_list));
+			assert(!list_empty(&area->used_space.leaf_list));
 			
 			btree_node_t *node =
@@ -893,7 +893,7 @@
 					    ptr + P2SZ(i), false, &pte);
 					
-					ASSERT(found);
-					ASSERT(PTE_VALID(&pte));
-					ASSERT(PTE_PRESENT(&pte));
+					assert(found);
+					assert(PTE_VALID(&pte));
+					assert(PTE_PRESENT(&pte));
 					
 					if ((area->backend) &&
@@ -1008,7 +1008,7 @@
 				     ptr + P2SZ(size), false, &pte);
 				
-				ASSERT(found);
-				ASSERT(PTE_VALID(&pte));
-				ASSERT(PTE_PRESENT(&pte));
+				assert(found);
+				assert(PTE_VALID(&pte));
+				assert(PTE_PRESENT(&pte));
 				
 				if ((area->backend) &&
@@ -1194,5 +1194,5 @@
 NO_TRACE bool as_area_check_access(as_area_t *area, pf_access_t access)
 {
-	ASSERT(mutex_locked(&area->lock));
+	assert(mutex_locked(&area->lock));
 	
 	int flagmap[] = {
@@ -1321,7 +1321,7 @@
 				    ptr + P2SZ(size), false, &pte);
 				
-				ASSERT(found);
-				ASSERT(PTE_VALID(&pte));
-				ASSERT(PTE_PRESENT(&pte));
+				assert(found);
+				assert(PTE_VALID(&pte));
+				assert(PTE_PRESENT(&pte));
 				
 				old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
@@ -1541,5 +1541,5 @@
 	 */
 	if (old_as) {
-		ASSERT(old_as->cpu_refcount);
+		assert(old_as->cpu_refcount);
 		
 		if ((--old_as->cpu_refcount == 0) && (old_as != AS_KERNEL)) {
@@ -1550,5 +1550,5 @@
 			 * ASID.
 			 */
-			ASSERT(old_as->asid != ASID_INVALID);
+			assert(old_as->asid != ASID_INVALID);
 			
 			list_append(&old_as->inactive_as_with_asid_link,
@@ -1597,5 +1597,5 @@
 NO_TRACE unsigned int as_area_get_flags(as_area_t *area)
 {
-	ASSERT(mutex_locked(&area->lock));
+	assert(mutex_locked(&area->lock));
 	
 	return area_flags_to_page_flags(area->flags);
@@ -1615,6 +1615,6 @@
 NO_TRACE pte_t *page_table_create(unsigned int flags)
 {
-	ASSERT(as_operations);
-	ASSERT(as_operations->page_table_create);
+	assert(as_operations);
+	assert(as_operations->page_table_create);
 	
 	return as_operations->page_table_create(flags);
@@ -1630,6 +1630,6 @@
 NO_TRACE void page_table_destroy(pte_t *page_table)
 {
-	ASSERT(as_operations);
-	ASSERT(as_operations->page_table_destroy);
+	assert(as_operations);
+	assert(as_operations->page_table_destroy);
 	
 	as_operations->page_table_destroy(page_table);
@@ -1651,6 +1651,6 @@
 NO_TRACE void page_table_lock(as_t *as, bool lock)
 {
-	ASSERT(as_operations);
-	ASSERT(as_operations->page_table_lock);
+	assert(as_operations);
+	assert(as_operations->page_table_lock);
 	
 	as_operations->page_table_lock(as, lock);
@@ -1665,6 +1665,6 @@
 NO_TRACE void page_table_unlock(as_t *as, bool unlock)
 {
-	ASSERT(as_operations);
-	ASSERT(as_operations->page_table_unlock);
+	assert(as_operations);
+	assert(as_operations->page_table_unlock);
 	
 	as_operations->page_table_unlock(as, unlock);
@@ -1680,6 +1680,6 @@
 NO_TRACE bool page_table_locked(as_t *as)
 {
-	ASSERT(as_operations);
-	ASSERT(as_operations->page_table_locked);
+	assert(as_operations);
+	assert(as_operations->page_table_locked);
 
 	return as_operations->page_table_locked(as);
@@ -1724,7 +1724,7 @@
 bool used_space_insert(as_area_t *area, uintptr_t page, size_t count)
 {
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(page, PAGE_SIZE));
-	ASSERT(count);
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(page, PAGE_SIZE));
+	assert(count);
 	
 	btree_node_t *leaf = NULL;
@@ -1737,5 +1737,5 @@
 	}
 
-	ASSERT(leaf != NULL);
+	assert(leaf != NULL);
 	
 	if (!leaf->keys) {
@@ -2010,7 +2010,7 @@
 bool used_space_remove(as_area_t *area, uintptr_t page, size_t count)
 {
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(page, PAGE_SIZE));
-	ASSERT(count);
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(page, PAGE_SIZE));
+	assert(count);
 	
 	btree_node_t *leaf;
@@ -2257,5 +2257,5 @@
 			as_area_t *area = node->value[i];
 			
-			ASSERT(area_idx < area_cnt);
+			assert(area_idx < area_cnt);
 			mutex_lock(&area->lock);
 			
Index: kernel/generic/src/mm/backend_anon.c
===================================================================
--- kernel/generic/src/mm/backend_anon.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/backend_anon.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,4 +37,5 @@
  */
 
+#include <assert.h>
 #include <mm/as.h>
 #include <mm/page.h>
@@ -113,7 +114,7 @@
 void anon_share(as_area_t *area)
 {
-	ASSERT(mutex_locked(&area->as->lock));
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(!(area->flags & AS_AREA_LATE_RESERVE));
+	assert(mutex_locked(&area->as->lock));
+	assert(mutex_locked(&area->lock));
+	assert(!(area->flags & AS_AREA_LATE_RESERVE));
 
 	/*
@@ -138,7 +139,7 @@
 				    base + P2SZ(j), false, &pte);
 
-				ASSERT(found);
-				ASSERT(PTE_VALID(&pte));
-				ASSERT(PTE_PRESENT(&pte));
+				assert(found);
+				assert(PTE_VALID(&pte));
+				assert(PTE_PRESENT(&pte));
 
 				btree_insert(&area->sh_info->pagemap,
@@ -190,7 +191,7 @@
 	uintptr_t frame;
 
-	ASSERT(page_table_locked(AS));
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
+	assert(page_table_locked(AS));
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(upage, PAGE_SIZE));
 
 	if (!as_area_check_access(area, access))
@@ -294,6 +295,6 @@
 void anon_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
-	ASSERT(page_table_locked(area->as));
-	ASSERT(mutex_locked(&area->lock));
+	assert(page_table_locked(area->as));
+	assert(mutex_locked(&area->lock));
 
 	if (area->flags & AS_AREA_LATE_RESERVE) {
Index: kernel/generic/src/mm/backend_elf.c
===================================================================
--- kernel/generic/src/mm/backend_elf.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/backend_elf.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,5 +37,5 @@
 
 #include <lib/elf.h>
-#include <debug.h>
+#include <assert.h>
 #include <typedefs.h>
 #include <mm/as.h>
@@ -142,6 +142,6 @@
 	uintptr_t start_anon = entry->p_vaddr + entry->p_filesz;
 
-	ASSERT(mutex_locked(&area->as->lock));
-	ASSERT(mutex_locked(&area->lock));
+	assert(mutex_locked(&area->as->lock));
+	assert(mutex_locked(&area->lock));
 
 	/*
@@ -200,7 +200,7 @@
 				    base + P2SZ(j), false, &pte);
 
-				ASSERT(found);
-				ASSERT(PTE_VALID(&pte));
-				ASSERT(PTE_PRESENT(&pte));
+				assert(found);
+				assert(PTE_VALID(&pte));
+				assert(PTE_PRESENT(&pte));
 
 				btree_insert(&area->sh_info->pagemap,
@@ -261,7 +261,7 @@
 	bool dirty = false;
 
-	ASSERT(page_table_locked(AS));
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
+	assert(page_table_locked(AS));
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(upage, PAGE_SIZE));
 
 	if (!as_area_check_access(area, access))
@@ -345,6 +345,6 @@
 			    base + i * FRAME_SIZE, true, &pte);
 
-			ASSERT(found);
-			ASSERT(PTE_PRESENT(&pte));
+			assert(found);
+			assert(PTE_PRESENT(&pte));
 
 			frame = PTE_GET_FRAME(&pte);
@@ -424,9 +424,9 @@
 	uintptr_t start_anon;
 
-	ASSERT(page_table_locked(area->as));
-	ASSERT(mutex_locked(&area->lock));
-
-	ASSERT(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
-	ASSERT(page < entry->p_vaddr + entry->p_memsz);
+	assert(page_table_locked(area->as));
+	assert(mutex_locked(&area->lock));
+
+	assert(page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE));
+	assert(page < entry->p_vaddr + entry->p_memsz);
 
 	start_anon = entry->p_vaddr + entry->p_filesz;
Index: kernel/generic/src/mm/backend_phys.c
===================================================================
--- kernel/generic/src/mm/backend_phys.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/backend_phys.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,5 +37,5 @@
  */
 
-#include <debug.h>
+#include <assert.h>
 #include <typedefs.h>
 #include <mm/as.h>
@@ -95,6 +95,6 @@
 void phys_share(as_area_t *area)
 {
-	ASSERT(mutex_locked(&area->as->lock));
-	ASSERT(mutex_locked(&area->lock));
+	assert(mutex_locked(&area->as->lock));
+	assert(mutex_locked(&area->lock));
 }
 
@@ -135,12 +135,12 @@
 	uintptr_t base = area->backend_data.base;
 
-	ASSERT(page_table_locked(AS));
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
+	assert(page_table_locked(AS));
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(upage, PAGE_SIZE));
 
 	if (!as_area_check_access(area, access))
 		return AS_PF_FAULT;
 
-	ASSERT(upage - area->base < area->backend_data.frames * FRAME_SIZE);
+	assert(upage - area->base < area->backend_data.frames * FRAME_SIZE);
 	page_mapping_insert(AS, upage, base + (upage - area->base),
 	    as_area_get_flags(area));
Index: kernel/generic/src/mm/backend_user.c
===================================================================
--- kernel/generic/src/mm/backend_user.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/backend_user.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -46,5 +46,5 @@
 #include <typedefs.h>
 #include <align.h>
-#include <debug.h>
+#include <assert.h>
 #include <errno.h>
 #include <log.h>
@@ -108,7 +108,7 @@
 int user_page_fault(as_area_t *area, uintptr_t upage, pf_access_t access)
 {
-	ASSERT(page_table_locked(AS));
-	ASSERT(mutex_locked(&area->lock));
-	ASSERT(IS_ALIGNED(upage, PAGE_SIZE));
+	assert(page_table_locked(AS));
+	assert(mutex_locked(&area->lock));
+	assert(IS_ALIGNED(upage, PAGE_SIZE));
 
 	if (!as_area_check_access(area, access))
@@ -162,6 +162,6 @@
 void user_frame_free(as_area_t *area, uintptr_t page, uintptr_t frame)
 {
-	ASSERT(page_table_locked(area->as));
-	ASSERT(mutex_locked(&area->lock));
+	assert(page_table_locked(area->as));
+	assert(mutex_locked(&area->lock));
 
 	pfn_t pfn = ADDR2PFN(frame);
Index: kernel/generic/src/mm/frame.c
===================================================================
--- kernel/generic/src/mm/frame.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/frame.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -47,5 +47,5 @@
 #include <mm/as.h>
 #include <panic.h>
-#include <debug.h>
+#include <assert.h>
 #include <adt/list.h>
 #include <synch/mutex.h>
@@ -349,5 +349,5 @@
 NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t index)
 {
-	ASSERT(index < zone->count);
+	assert(index < zone->count);
 	
 	return &zone->frames[index];
@@ -370,5 +370,5 @@
     pfn_t constraint)
 {
-	ASSERT(zone->flags & ZONE_AVAILABLE);
+	assert(zone->flags & ZONE_AVAILABLE);
 	
 	/* Allocate frames from zone */
@@ -377,6 +377,6 @@
 	    FRAME_LOWPRIO, constraint, &index);
 	
-	ASSERT(avail);
-	ASSERT(index != (size_t) -1);
+	assert(avail);
+	assert(index != (size_t) -1);
 	
 	/* Update frame reference count */
@@ -384,5 +384,5 @@
 		frame_t *frame = zone_get_frame(zone, index + i);
 		
-		ASSERT(frame->refcount == 0);
+		assert(frame->refcount == 0);
 		frame->refcount = 1;
 	}
@@ -407,9 +407,9 @@
 NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t index)
 {
-	ASSERT(zone->flags & ZONE_AVAILABLE);
+	assert(zone->flags & ZONE_AVAILABLE);
 	
 	frame_t *frame = zone_get_frame(zone, index);
 	
-	ASSERT(frame->refcount > 0);
+	assert(frame->refcount > 0);
 	
 	if (!--frame->refcount) {
@@ -429,5 +429,5 @@
 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t index)
 {
-	ASSERT(zone->flags & ZONE_AVAILABLE);
+	assert(zone->flags & ZONE_AVAILABLE);
 	
 	frame_t *frame = zone_get_frame(zone, index);
@@ -456,9 +456,9 @@
     void *confdata)
 {
-	ASSERT(zones.info[z1].flags & ZONE_AVAILABLE);
-	ASSERT(zones.info[z2].flags & ZONE_AVAILABLE);
-	ASSERT(zones.info[z1].flags == zones.info[z2].flags);
-	ASSERT(zones.info[z1].base < zones.info[z2].base);
-	ASSERT(!overlaps(zones.info[z1].base, zones.info[z1].count,
+	assert(zones.info[z1].flags & ZONE_AVAILABLE);
+	assert(zones.info[z2].flags & ZONE_AVAILABLE);
+	assert(zones.info[z1].flags == zones.info[z2].flags);
+	assert(zones.info[z1].base < zones.info[z2].base);
+	assert(!overlaps(zones.info[z1].base, zones.info[z1].count,
 	    zones.info[z2].base, zones.info[z2].count));
 	
@@ -509,5 +509,5 @@
 NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
 {
-	ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
+	assert(zones.info[znum].flags & ZONE_AVAILABLE);
 	
 	size_t cframes = SIZE2FRAMES(zone_conf_size(count));
@@ -704,5 +704,5 @@
 		 * the assert
 		 */
-		ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
+		assert(confframe != ADDR2PFN((uintptr_t ) NULL));
 		
 		/* Update the known end of physical memory. */
@@ -792,5 +792,5 @@
 	size_t znum = find_zone(pfn, 1, hint);
 	
-	ASSERT(znum != (size_t) -1);
+	assert(znum != (size_t) -1);
 	
 	zone_get_frame(&zones.info[znum],
@@ -806,5 +806,5 @@
 	size_t znum = find_zone(pfn, 1, hint);
 	
-	ASSERT(znum != (size_t) -1);
+	assert(znum != (size_t) -1);
 	
 	void *res = zone_get_frame(&zones.info[znum],
@@ -830,5 +830,5 @@
     uintptr_t constraint, size_t *pzone)
 {
-	ASSERT(count > 0);
+	assert(count > 0);
 	
 	size_t hint = pzone ? (*pzone) : 0;
@@ -970,5 +970,5 @@
 		size_t znum = find_zone(pfn, 1, 0);
 		
-		ASSERT(znum != (size_t) -1);
+		assert(znum != (size_t) -1);
 		
 		freed += zone_frame_free(&zones.info[znum],
@@ -1030,5 +1030,5 @@
 	size_t znum = find_zone(pfn, 1, 0);
 	
-	ASSERT(znum != (size_t) -1);
+	assert(znum != (size_t) -1);
 	
 	zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
@@ -1153,8 +1153,8 @@
     uint64_t *free)
 {
-	ASSERT(total != NULL);
-	ASSERT(unavail != NULL);
-	ASSERT(busy != NULL);
-	ASSERT(free != NULL);
+	assert(total != NULL);
+	assert(unavail != NULL);
+	assert(busy != NULL);
+	assert(free != NULL);
 	
 	irq_spinlock_lock(&zones.lock, true);
Index: kernel/generic/src/mm/km.c
===================================================================
--- kernel/generic/src/mm/km.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/km.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,4 +38,5 @@
 #include <mm/km.h>
 #include <arch/mm/km.h>
+#include <assert.h>
 #include <mm/page.h>
 #include <mm/frame.h>
@@ -44,5 +45,4 @@
 #include <typedefs.h>
 #include <lib/ra.h>
-#include <debug.h>
 #include <arch.h>
 #include <align.h>
@@ -95,5 +95,5 @@
 {
 	km_ni_arena = ra_arena_create();
-	ASSERT(km_ni_arena != NULL);
+	assert(km_ni_arena != NULL);
 	km_non_identity_arch_init();
 	config.non_identity_configured = true;
@@ -112,5 +112,5 @@
 
 	span_added = ra_span_add(km_ni_arena, base, size);
-	ASSERT(span_added);
+	assert(span_added);
 }
 
@@ -132,6 +132,6 @@
 	uintptr_t offs;
 
-	ASSERT(ALIGN_DOWN(paddr, FRAME_SIZE) == paddr);
-	ASSERT(ALIGN_UP(size, FRAME_SIZE) == size);
+	assert(ALIGN_DOWN(paddr, FRAME_SIZE) == paddr);
+	assert(ALIGN_UP(size, FRAME_SIZE) == size);
 
 	/* Enforce natural or at least PAGE_SIZE alignment. */
@@ -154,6 +154,6 @@
 	ipl_t ipl;
 
-	ASSERT(ALIGN_DOWN(vaddr, PAGE_SIZE) == vaddr);
-	ASSERT(ALIGN_UP(size, PAGE_SIZE) == size);
+	assert(ALIGN_DOWN(vaddr, PAGE_SIZE) == vaddr);
+	assert(ALIGN_UP(size, PAGE_SIZE) == size);
 
 	page_table_lock(AS_KERNEL, true);
@@ -240,7 +240,7 @@
 uintptr_t km_temporary_page_get(uintptr_t *framep, frame_flags_t flags)
 {
-	ASSERT(THREAD);
-	ASSERT(framep);
-	ASSERT(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
+	assert(THREAD);
+	assert(framep);
+	assert(!(flags & ~(FRAME_NO_RESERVE | FRAME_ATOMIC)));
 	
 	/*
@@ -281,5 +281,5 @@
 void km_temporary_page_put(uintptr_t page)
 {
-	ASSERT(THREAD);
+	assert(THREAD);
 
 	if (km_is_non_identity(page))
Index: kernel/generic/src/mm/page.c
===================================================================
--- kernel/generic/src/mm/page.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/page.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -69,6 +69,6 @@
 #include <typedefs.h>
 #include <arch/asm.h>
-#include <debug.h>
 #include <arch.h>
+#include <assert.h>
 #include <syscall/copy.h>
 #include <errno.h>
@@ -98,8 +98,8 @@
     unsigned int flags)
 {
-	ASSERT(page_table_locked(as));
-	
-	ASSERT(page_mapping_operations);
-	ASSERT(page_mapping_operations->mapping_insert);
+	assert(page_table_locked(as));
+	
+	assert(page_mapping_operations);
+	assert(page_mapping_operations->mapping_insert);
 
 	page_mapping_operations->mapping_insert(as, ALIGN_DOWN(page, PAGE_SIZE),
@@ -122,8 +122,8 @@
 NO_TRACE void page_mapping_remove(as_t *as, uintptr_t page)
 {
-	ASSERT(page_table_locked(as));
-	
-	ASSERT(page_mapping_operations);
-	ASSERT(page_mapping_operations->mapping_remove);
+	assert(page_table_locked(as));
+	
+	assert(page_mapping_operations);
+	assert(page_mapping_operations->mapping_remove);
 	
 	page_mapping_operations->mapping_remove(as,
@@ -147,8 +147,8 @@
     pte_t *pte)
 {
-	ASSERT(nolock || page_table_locked(as));
-	
-	ASSERT(page_mapping_operations);
-	ASSERT(page_mapping_operations->mapping_find);
+	assert(nolock || page_table_locked(as));
+	
+	assert(page_mapping_operations);
+	assert(page_mapping_operations->mapping_find);
 	
 	return page_mapping_operations->mapping_find(as,
@@ -168,8 +168,8 @@
     pte_t *pte)
 {
-	ASSERT(nolock || page_table_locked(as));
-	
-	ASSERT(page_mapping_operations);
-	ASSERT(page_mapping_operations->mapping_find);
+	assert(nolock || page_table_locked(as));
+	
+	assert(page_mapping_operations);
+	assert(page_mapping_operations->mapping_find);
 	
 	page_mapping_operations->mapping_update(as,
@@ -184,6 +184,6 @@
 void page_mapping_make_global(uintptr_t base, size_t size)
 {
-	ASSERT(page_mapping_operations);
-	ASSERT(page_mapping_operations->mapping_make_global);
+	assert(page_mapping_operations);
+	assert(page_mapping_operations->mapping_make_global);
 	
 	return page_mapping_operations->mapping_make_global(base, size);
Index: kernel/generic/src/mm/reserve.c
===================================================================
--- kernel/generic/src/mm/reserve.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/reserve.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
  */
 
+#include <assert.h>
 #include <mm/reserve.h>
 #include <mm/frame.h>
@@ -42,5 +43,4 @@
 #include <typedefs.h>
 #include <arch/types.h>
-#include <debug.h>
 
 static bool reserve_initialized = false;
@@ -72,5 +72,5 @@
 	bool reserved = false;
 
-	ASSERT(reserve_initialized);
+	assert(reserve_initialized);
 
 	irq_spinlock_lock(&reserve_lock, true);
Index: kernel/generic/src/mm/slab.c
===================================================================
--- kernel/generic/src/mm/slab.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/slab.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -101,4 +101,5 @@
  */
 
+#include <assert.h>
 #include <synch/spinlock.h>
 #include <mm/slab.h>
@@ -111,5 +112,4 @@
 #include <arch.h>
 #include <panic.h>
-#include <debug.h>
 #include <bitops.h>
 #include <macros.h>
@@ -260,5 +260,5 @@
 		slab = obj2slab(obj);
 	
-	ASSERT(slab->cache == cache);
+	assert(slab->cache == cache);
 	
 	size_t freed = 0;
@@ -268,5 +268,5 @@
 	
 	irq_spinlock_lock(&cache->slablock, true);
-	ASSERT(slab->available < cache->objects);
+	assert(slab->available < cache->objects);
 	
 	*((size_t *) obj) = slab->nextavail;
@@ -417,5 +417,5 @@
 	slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
 	
-	ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
+	assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
 	
 	if (cmag) { /* First try local CPU magazines */
@@ -484,5 +484,5 @@
 	slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
 	
-	ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
+	assert(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
 	
 	if (cmag) {
@@ -586,5 +586,5 @@
 NO_TRACE static bool make_magcache(slab_cache_t *cache)
 {
-	ASSERT(_slab_initialized >= 2);
+	assert(_slab_initialized >= 2);
 	
 	cache->mag_cache = malloc(sizeof(slab_mag_cache_t) * config.cpu_count,
@@ -610,5 +610,5 @@
     unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
 {
-	ASSERT(size > 0);
+	assert(size > 0);
 	
 	memsetb(cache, sizeof(*cache), 0);
@@ -948,6 +948,6 @@
 void *malloc(size_t size, unsigned int flags)
 {
-	ASSERT(_slab_initialized);
-	ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
+	assert(_slab_initialized);
+	assert(size <= (1 << SLAB_MAX_MALLOC_W));
 	
 	if (size < (1 << SLAB_MIN_MALLOC_W))
@@ -961,6 +961,6 @@
 void *realloc(void *ptr, size_t size, unsigned int flags)
 {
-	ASSERT(_slab_initialized);
-	ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
+	assert(_slab_initialized);
+	assert(size <= (1 << SLAB_MAX_MALLOC_W));
 	
 	void *new_ptr;
Index: kernel/generic/src/mm/tlb.c
===================================================================
--- kernel/generic/src/mm/tlb.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/mm/tlb.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -43,4 +43,5 @@
 #include <mm/asid.h>
 #include <arch/mm/tlb.h>
+#include <assert.h>
 #include <smp/ipi.h>
 #include <synch/spinlock.h>
@@ -50,5 +51,4 @@
 #include <arch.h>
 #include <panic.h>
-#include <debug.h>
 #include <cpu.h>
 
@@ -152,5 +152,5 @@
 void tlb_shootdown_ipi_recv(void)
 {
-	ASSERT(CPU);
+	assert(CPU);
 	
 	CPU->tlb_active = false;
@@ -159,5 +159,5 @@
 	
 	irq_spinlock_lock(&CPU->lock, false);
-	ASSERT(CPU->tlb_messages_count <= TLB_MESSAGE_QUEUE_LEN);
+	assert(CPU->tlb_messages_count <= TLB_MESSAGE_QUEUE_LEN);
 	
 	size_t i;
@@ -176,5 +176,5 @@
 			break;
 		case TLB_INVL_PAGES:
-			ASSERT(count);
+			assert(count);
 			tlb_invalidate_pages(asid, page, count);
 			break;
Index: kernel/generic/src/proc/scheduler.c
===================================================================
--- kernel/generic/src/proc/scheduler.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/proc/scheduler.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,4 +39,5 @@
  */
 
+#include <assert.h>
 #include <proc/scheduler.h>
 #include <proc/thread.h>
@@ -64,5 +65,4 @@
 #include <print.h>
 #include <log.h>
-#include <debug.h>
 #include <stacktrace.h>
 
@@ -200,5 +200,5 @@
 static thread_t *find_best_thread(void)
 {
-	ASSERT(CPU != NULL);
+	assert(CPU != NULL);
 	
 loop:
@@ -225,5 +225,5 @@
 	}
 
-	ASSERT(!CPU->idle);
+	assert(!CPU->idle);
 	
 	unsigned int i;
@@ -322,5 +322,5 @@
 	volatile ipl_t ipl;
 	
-	ASSERT(CPU != NULL);
+	assert(CPU != NULL);
 	
 	ipl = interrupts_disable();
@@ -403,7 +403,7 @@
 	as_t *old_as = AS;
 	
-	ASSERT((!THREAD) || (irq_spinlock_locked(&THREAD->lock)));
-	ASSERT(CPU != NULL);
-	ASSERT(interrupts_disabled());
+	assert((!THREAD) || (irq_spinlock_locked(&THREAD->lock)));
+	assert(CPU != NULL);
+	assert(interrupts_disabled());
 	
 	/*
Index: kernel/generic/src/proc/task.c
===================================================================
--- kernel/generic/src/proc/task.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/proc/task.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
  */
 
+#include <assert.h>
 #include <proc/thread.h>
 #include <proc/task.h>
@@ -419,6 +420,6 @@
 task_t *task_find_by_id(task_id_t id)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&tasks_lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&tasks_lock));
 
 	avltree_node_t *node =
@@ -443,6 +444,6 @@
 void task_get_accounting(task_t *task, uint64_t *ucycles, uint64_t *kcycles)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&task->lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&task->lock));
 
 	/* Accumulated values of task */
Index: kernel/generic/src/proc/the.c
===================================================================
--- kernel/generic/src/proc/the.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/proc/the.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -43,5 +43,5 @@
 
 #include <arch.h>
-#include <debug.h>
+#include <assert.h>
 
 /** Initialize THE structure
@@ -60,5 +60,5 @@
 	the->as = NULL;
 	the->magic = MAGIC;
-#ifdef RCU_PREEMPT_A	
+#ifdef RCU_PREEMPT_A
 	the->rcu_nesting = 0;
 #endif
@@ -75,5 +75,5 @@
 NO_TRACE void the_copy(the_t *src, the_t *dst)
 {
-	ASSERT(src->magic == MAGIC);
+	assert(src->magic == MAGIC);
 	*dst = *src;
 }
Index: kernel/generic/src/proc/thread.c
===================================================================
--- kernel/generic/src/proc/thread.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/proc/thread.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,4 +36,5 @@
  */
 
+#include <assert.h>
 #include <proc/scheduler.h>
 #include <proc/thread.h>
@@ -64,5 +65,4 @@
 #include <print.h>
 #include <mm/slab.h>
-#include <debug.h>
 #include <main/uinit.h>
 #include <syscall/copy.h>
@@ -268,5 +268,5 @@
 static void before_thread_is_ready(thread_t *thread)
 {
-	ASSERT(irq_spinlock_locked(&thread->lock));
+	assert(irq_spinlock_locked(&thread->lock));
 	workq_before_thread_is_ready(thread);
 }
@@ -283,5 +283,5 @@
 	irq_spinlock_lock(&thread->lock, true);
 	
-	ASSERT(thread->state != Ready);
+	assert(thread->state != Ready);
 
 	before_thread_is_ready(thread);
@@ -293,5 +293,5 @@
 	if (thread->wired || thread->nomigrate || thread->fpu_context_engaged) {
 		/* Cannot ready to another CPU */
-		ASSERT(thread->cpu != NULL);
+		assert(thread->cpu != NULL);
 		cpu = thread->cpu;
 	} else if (thread->stolen) {
@@ -300,5 +300,5 @@
 	} else if (thread->cpu) {
 		/* Prefer the CPU on which the thread ran last */
-		ASSERT(thread->cpu != NULL);
+		assert(thread->cpu != NULL);
 		cpu = thread->cpu;
 	} else {
@@ -431,8 +431,8 @@
 void thread_destroy(thread_t *thread, bool irq_res)
 {
-	ASSERT(irq_spinlock_locked(&thread->lock));
-	ASSERT((thread->state == Exiting) || (thread->state == Lingering));
-	ASSERT(thread->task);
-	ASSERT(thread->cpu);
+	assert(irq_spinlock_locked(&thread->lock));
+	assert((thread->state == Exiting) || (thread->state == Lingering));
+	assert(thread->task);
+	assert(thread->cpu);
 	
 	irq_spinlock_lock(&thread->cpu->lock, false);
@@ -561,5 +561,5 @@
 void thread_interrupt(thread_t *thread)
 {
-	ASSERT(thread != NULL);
+	assert(thread != NULL);
 	
 	irq_spinlock_lock(&thread->lock, true);
@@ -582,5 +582,5 @@
 bool thread_interrupted(thread_t *thread)
 {
-	ASSERT(thread != NULL);
+	assert(thread != NULL);
 	
 	bool interrupted;
@@ -596,5 +596,5 @@
 void thread_migration_disable(void)
 {
-	ASSERT(THREAD);
+	assert(THREAD);
 	
 	THREAD->nomigrate++;
@@ -604,6 +604,6 @@
 void thread_migration_enable(void)
 {
-	ASSERT(THREAD);
-	ASSERT(THREAD->nomigrate > 0);
+	assert(THREAD);
+	assert(THREAD->nomigrate > 0);
 	
 	if (THREAD->nomigrate > 0)
@@ -650,5 +650,5 @@
 	
 	irq_spinlock_lock(&thread->lock, true);
-	ASSERT(!thread->detached);
+	assert(!thread->detached);
 	irq_spinlock_unlock(&thread->lock, true);
 	
@@ -671,5 +671,5 @@
 	 */
 	irq_spinlock_lock(&thread->lock, true);
-	ASSERT(!thread->detached);
+	assert(!thread->detached);
 	
 	if (thread->state == Lingering) {
@@ -809,6 +809,6 @@
 bool thread_exists(thread_t *thread)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&threads_lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&threads_lock));
 
 	avltree_node_t *node =
@@ -830,6 +830,6 @@
 	uint64_t time = get_cycle();
 
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&THREAD->lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&THREAD->lock));
 	
 	if (user)
@@ -867,6 +867,6 @@
 thread_t *thread_find_by_id(thread_id_t thread_id)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&threads_lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&threads_lock));
 	
 	thread_iterator_t iterator;
Index: kernel/generic/src/smp/smp_call.c
===================================================================
--- kernel/generic/src/smp/smp_call.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/smp/smp_call.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -40,7 +40,7 @@
 #include <arch/asm.h>  /* interrupt_disable */
 #include <arch.h>
+#include <assert.h>
 #include <config.h>
 #include <preemption.h>
-#include <debug.h>
 #include <cpu.h>
 
@@ -53,6 +53,6 @@
 void smp_call_init(void)
 {
-	ASSERT(CPU);
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(CPU);
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
 	spinlock_initialize(&CPU->smp_calls_lock, "cpu[].smp_calls_lock");
@@ -131,6 +131,6 @@
 	 * for an acknowledgment of the IPI from the other cpu.
 	 */
-	ASSERT(!interrupts_disabled());
-	ASSERT(call_info != NULL);
+	assert(!interrupts_disabled());
+	assert(call_info != NULL);
 	
 	/* Discard invalid calls. */
@@ -207,6 +207,6 @@
 void smp_call_ipi_recv(void)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(CPU);
+	assert(interrupts_disabled());
+	assert(CPU);
 	
 	list_t calls_list;
Index: kernel/generic/src/synch/futex.c
===================================================================
--- kernel/generic/src/synch/futex.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/synch/futex.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -61,4 +61,5 @@
  */
 
+#include <assert.h>
 #include <synch/futex.h>
 #include <synch/mutex.h>
@@ -241,6 +242,6 @@
 static void futex_add_ref(futex_t *futex)
 {
-	ASSERT(spinlock_locked(&futex_ht_lock));
-	ASSERT(0 < futex->refcount);
+	assert(spinlock_locked(&futex_ht_lock));
+	assert(0 < futex->refcount);
 	++futex->refcount;
 }
@@ -249,6 +250,6 @@
 static void futex_release_ref(futex_t *futex)
 {
-	ASSERT(spinlock_locked(&futex_ht_lock));
-	ASSERT(0 < futex->refcount);
+	assert(spinlock_locked(&futex_ht_lock));
+	assert(0 < futex->refcount);
 	
 	--futex->refcount;
@@ -459,5 +460,5 @@
 	futex_t *futex;
 
-	ASSERT(keys == 1);
+	assert(keys == 1);
 
 	futex = hash_table_get_instance(item, futex_t, ht_link);
Index: kernel/generic/src/synch/mutex.c
===================================================================
--- kernel/generic/src/synch/mutex.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/synch/mutex.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -36,7 +36,7 @@
  */
 
+#include <assert.h>
 #include <synch/mutex.h>
 #include <synch/semaphore.h>
-#include <debug.h>
 #include <arch.h>
 #include <stacktrace.h>
@@ -88,7 +88,7 @@
 		rc = _semaphore_down_timeout(&mtx->sem, usec, flags);
 	} else {
-		ASSERT((mtx->type == MUTEX_ACTIVE) || (!THREAD));
-		ASSERT(usec == SYNCH_NO_TIMEOUT);
-		ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
+		assert((mtx->type == MUTEX_ACTIVE) || (!THREAD));
+		assert(usec == SYNCH_NO_TIMEOUT);
+		assert(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
 		
 		unsigned int cnt = 0;
Index: kernel/generic/src/synch/rcu.c
===================================================================
--- kernel/generic/src/synch/rcu.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/synch/rcu.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -123,5 +123,6 @@
  * 
  */
- 
+
+#include <assert.h>
 #include <synch/rcu.h>
 #include <synch/condvar.h>
@@ -404,5 +405,5 @@
 	/* Stop and wait for reclaimers. */
 	for (unsigned int cpu_id = 0; cpu_id < config.cpu_active; ++cpu_id) {
-		ASSERT(cpus[cpu_id].rcu.reclaimer_thr != NULL);
+		assert(cpus[cpu_id].rcu.reclaimer_thr != NULL);
 	
 		if (cpus[cpu_id].rcu.reclaimer_thr) {
@@ -487,5 +488,5 @@
 static void read_unlock_impl(size_t *pnesting_cnt)
 {
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
 	if (0 == --(*pnesting_cnt)) {
@@ -509,5 +510,5 @@
 void _rcu_signal_read_unlock(void)
 {
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
 	/*
@@ -531,5 +532,5 @@
 	 */
 	if (THREAD && local_atomic_exchange(&THREAD->rcu.was_preempted, false)) {
-		ASSERT(link_used(&THREAD->rcu.preempt_link));
+		assert(link_used(&THREAD->rcu.preempt_link));
 
 		rm_preempted_reader();
@@ -563,5 +564,5 @@
 {
 	/* Calling from a reader section will deadlock. */
-	ASSERT(!rcu_read_locked());
+	assert(!rcu_read_locked());
 	
 	synch_item_t completion; 
@@ -576,5 +577,5 @@
 {
 	synch_item_t *completion = member_to_inst(rcu_item, synch_item_t, rcu_item);
-	ASSERT(completion);
+	assert(completion);
 	waitq_wakeup(&completion->wq, WAKEUP_FIRST);
 }
@@ -615,5 +616,5 @@
 static void add_barrier_cb(void *arg)
 {
-	ASSERT(interrupts_disabled() || PREEMPTION_DISABLED);
+	assert(interrupts_disabled() || PREEMPTION_DISABLED);
 	atomic_inc(&rcu.barrier_wait_cnt);
 	rcu_call(&CPU->rcu.barrier_item, barrier_complete);
@@ -657,5 +658,5 @@
 	rcu_func_t func)
 {
-	ASSERT(rcu_item);
+	assert(rcu_item);
 	
 	rcu_item->func = func;
@@ -689,5 +690,5 @@
 static bool cur_cbs_empty(void)
 {
-	ASSERT(THREAD && THREAD->wired);
+	assert(THREAD && THREAD->wired);
 	return NULL == CPU->rcu.cur_cbs;
 }
@@ -695,5 +696,5 @@
 static bool next_cbs_empty(void)
 {
-	ASSERT(THREAD && THREAD->wired);
+	assert(THREAD && THREAD->wired);
 	return NULL == CPU->rcu.next_cbs;
 }
@@ -702,5 +703,5 @@
 static bool arriving_cbs_empty(void)
 {
-	ASSERT(THREAD && THREAD->wired);
+	assert(THREAD && THREAD->wired);
 	/* 
 	 * Accessing with interrupts enabled may at worst lead to 
@@ -719,6 +720,6 @@
 static void reclaimer(void *arg)
 {
-	ASSERT(THREAD && THREAD->wired);
-	ASSERT(THREAD == CPU->rcu.reclaimer_thr);
+	assert(THREAD && THREAD->wired);
+	assert(THREAD == CPU->rcu.reclaimer_thr);
 
 	rcu_gp_t last_compl_gp = 0;
@@ -726,5 +727,5 @@
 	
 	while (ok && wait_for_pending_cbs()) {
-		ASSERT(CPU->rcu.reclaimer_thr == THREAD);
+		assert(CPU->rcu.reclaimer_thr == THREAD);
 		
 		exec_completed_cbs(last_compl_gp);
@@ -765,5 +766,5 @@
 	/* Both next_cbs and cur_cbs GP elapsed. */
 	if (CPU->rcu.next_cbs_gp <= last_completed_gp) {
-		ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+		assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
 		
 		size_t exec_cnt = CPU->rcu.cur_cbs_cnt + CPU->rcu.next_cbs_cnt;
@@ -864,5 +865,5 @@
 	 */
 	if (CPU->rcu.next_cbs) {
-		ASSERT(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
+		assert(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
 		
 		CPU->rcu.arriving_cbs = NULL;
@@ -913,5 +914,5 @@
 	}
 	
-	ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+	assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
 	
 	return expedite;	
@@ -933,6 +934,6 @@
 	spinlock_lock(&rcu.gp_lock);
 
-	ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-	ASSERT(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
+	assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+	assert(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
 	
 	while (rcu.completed_gp < CPU->rcu.cur_cbs_gp) {
@@ -1029,5 +1030,5 @@
 static void sample_local_cpu(void *arg)
 {
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 	cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
 	
@@ -1054,5 +1055,5 @@
 void rcu_after_thread_ran(void)
 {
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 
 	/* 
@@ -1116,5 +1117,5 @@
 void rcu_before_thread_runs(void)
 {
-	ASSERT(!rcu_read_locked());
+	assert(!rcu_read_locked());
 	
 	/* Load the thread's saved nesting count from before it was preempted. */
@@ -1129,5 +1130,5 @@
 void rcu_thread_exiting(void)
 {
-	ASSERT(THE->rcu_nesting == 0);
+	assert(THE->rcu_nesting == 0);
 	
 	/* 
@@ -1157,5 +1158,5 @@
 void _rcu_preempted_unlock(void)
 {
-	ASSERT(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
+	assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
 	
 	size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
@@ -1220,6 +1221,6 @@
 	}
 	
-	ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-	ASSERT(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
+	assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+	assert(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
 	
 	/* 
@@ -1262,5 +1263,5 @@
 static bool cv_wait_for_gp(rcu_gp_t wait_on_gp)
 {
-	ASSERT(spinlock_locked(&rcu.gp_lock));
+	assert(spinlock_locked(&rcu.gp_lock));
 	
 	bool interrupted = false;
@@ -1284,5 +1285,5 @@
 
 		if (detector_idle) {
-			ASSERT(_rcu_cur_gp == rcu.completed_gp);
+			assert(_rcu_cur_gp == rcu.completed_gp);
 			condvar_signal(&rcu.req_gp_changed);
 		}
@@ -1323,5 +1324,5 @@
 static bool wait_for_detect_req(void)
 {
-	ASSERT(spinlock_locked(&rcu.gp_lock));
+	assert(spinlock_locked(&rcu.gp_lock));
 	
 	bool interrupted = false;
@@ -1340,5 +1341,5 @@
 static void end_cur_gp(void)
 {
-	ASSERT(spinlock_locked(&rcu.gp_lock));
+	assert(spinlock_locked(&rcu.gp_lock));
 	
 	rcu.completed_gp = _rcu_cur_gp;
@@ -1423,6 +1424,6 @@
 static void sample_local_cpu(void *arg)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(!CPU->rcu.is_delaying_gp);
+	assert(interrupts_disabled());
+	assert(!CPU->rcu.is_delaying_gp);
 	
 	/* Cpu did not pass a quiescent state yet. */
@@ -1430,5 +1431,5 @@
 		/* Interrupted a reader in a reader critical section. */
 		if (0 < CPU->rcu.nesting_cnt) {
-			ASSERT(!CPU->idle);
+			assert(!CPU->idle);
 			/* 
 			 * Note to notify the detector from rcu_read_unlock(). 
@@ -1492,5 +1493,5 @@
 void rcu_after_thread_ran(void)
 {
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 
 	/* 
@@ -1559,6 +1560,6 @@
 void rcu_before_thread_runs(void)
 {
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
-	ASSERT(0 == CPU->rcu.nesting_cnt);
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(0 == CPU->rcu.nesting_cnt);
 	
 	/* Load the thread's saved nesting count from before it was preempted. */
@@ -1590,7 +1591,7 @@
 void rcu_thread_exiting(void)
 {
-	ASSERT(THREAD != NULL);
-	ASSERT(THREAD->state == Exiting);
-	ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+	assert(THREAD != NULL);
+	assert(THREAD->state == Exiting);
+	assert(PREEMPTION_DISABLED || interrupts_disabled());
 	
 	/* 
@@ -1615,5 +1616,5 @@
 static void start_new_gp(void)
 {
-	ASSERT(spinlock_locked(&rcu.gp_lock));
+	assert(spinlock_locked(&rcu.gp_lock));
 	
 	irq_spinlock_lock(&rcu.preempt_lock, true);
@@ -1734,5 +1735,5 @@
 static void upd_missed_gp_in_wait(rcu_gp_t completed_gp)
 {
-	ASSERT(CPU->rcu.cur_cbs_gp <= completed_gp);
+	assert(CPU->rcu.cur_cbs_gp <= completed_gp);
 	
 	size_t delta = (size_t)(completed_gp - CPU->rcu.cur_cbs_gp);
@@ -1764,5 +1765,5 @@
 	irq_spinlock_lock(&rcu.preempt_lock, true);
 	
-	ASSERT(link_used(&THREAD->rcu.preempt_link));
+	assert(link_used(&THREAD->rcu.preempt_link));
 
 	bool prev_empty = list_empty(&rcu.cur_preempted);
Index: kernel/generic/src/synch/waitq.c
===================================================================
--- kernel/generic/src/synch/waitq.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/synch/waitq.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -44,4 +44,5 @@
  */
 
+#include <assert.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
@@ -203,5 +204,5 @@
 		irq_spinlock_lock(&thread->lock, false);
 		
-		ASSERT(thread->sleep_interruptible);
+		assert(thread->sleep_interruptible);
 		
 		if ((thread->timeout_pending) &&
@@ -264,5 +265,5 @@
 int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags)
 {
-	ASSERT((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
+	assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
 	
 	ipl_t ipl = waitq_sleep_prepare(wq);
@@ -496,5 +497,5 @@
 static void waitq_complete_wakeup(waitq_t *wq)
 {
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 	
 	irq_spinlock_lock(&wq->lock, false);
@@ -520,6 +521,6 @@
 	size_t count = 0;
 
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&wq->lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&wq->lock));
 	
 loop:
Index: kernel/generic/src/synch/workqueue.c
===================================================================
--- kernel/generic/src/synch/workqueue.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/synch/workqueue.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -37,4 +37,5 @@
  */
 
+#include <assert.h>
 #include <synch/workqueue.h>
 #include <synch/spinlock.h>
@@ -189,5 +190,5 @@
 	if (workq) {
 		if (workq_init(workq, name)) {
-			ASSERT(!workq_corrupted(workq));
+			assert(!workq_corrupted(workq));
 			return workq;
 		}
@@ -202,5 +203,5 @@
 void workq_destroy(struct work_queue *workq)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 	
 	irq_spinlock_lock(&workq->lock, true);
@@ -214,5 +215,5 @@
 		workq_stop(workq);
 	} else {
-		ASSERT(0 == running_workers);
+		assert(0 == running_workers);
 	}
 	
@@ -264,5 +265,5 @@
 static bool add_worker(struct work_queue *workq)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 
 	thread_t *thread = thread_create(worker_thread, workq, TASK, 
@@ -273,5 +274,5 @@
 		
 		/* cur_worker_cnt proactively increased in signal_worker_logic() .*/
-		ASSERT(0 < workq->cur_worker_cnt);
+		assert(0 < workq->cur_worker_cnt);
 		--workq->cur_worker_cnt;
 		
@@ -312,5 +313,5 @@
 		
 		/* cur_worker_cnt proactively increased in signal_worker() .*/
-		ASSERT(0 < workq->cur_worker_cnt);
+		assert(0 < workq->cur_worker_cnt);
 		--workq->cur_worker_cnt;
 	}
@@ -334,5 +335,5 @@
 void workq_stop(struct work_queue *workq)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 	
 	interrupt_workers(workq);
@@ -346,5 +347,5 @@
 
 	/* workq_stop() may only be called once. */
-	ASSERT(!workq->stopping);
+	assert(!workq->stopping);
 	workq->stopping = true;
 	
@@ -358,5 +359,5 @@
 static void wait_for_workers(struct work_queue *workq)
 {
-	ASSERT(!PREEMPTION_DISABLED);
+	assert(!PREEMPTION_DISABLED);
 	
 	irq_spinlock_lock(&workq->lock, true);
@@ -375,5 +376,5 @@
 	}
 	
-	ASSERT(list_empty(&workq->workers));
+	assert(list_empty(&workq->workers));
 	
 	/* Wait for deferred add_worker_op(), signal_worker_op() to finish. */
@@ -473,5 +474,5 @@
 	work_func_t func, bool can_block)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 	
 	bool success = true;
@@ -521,17 +522,17 @@
 static size_t active_workers_now(struct work_queue *workq)
 {
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	/* Workers blocked are sleeping in the work function (ie not idle). */
-	ASSERT(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
+	assert(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
 	/* Idle workers are waiting for more work to arrive in condvar_wait. */
-	ASSERT(workq->idle_worker_cnt <= workq->cur_worker_cnt);
+	assert(workq->idle_worker_cnt <= workq->cur_worker_cnt);
 	
 	/* Idle + blocked workers == sleeping worker threads. */
 	size_t sleeping_workers = workq->blocked_worker_cnt + workq->idle_worker_cnt;
 	
-	ASSERT(sleeping_workers	<= workq->cur_worker_cnt);
+	assert(sleeping_workers	<= workq->cur_worker_cnt);
 	/* Workers pending activation are idle workers not yet given a time slice. */
-	ASSERT(workq->activate_pending <= workq->idle_worker_cnt);
+	assert(workq->activate_pending <= workq->idle_worker_cnt);
 	
 	/* 
@@ -550,5 +551,5 @@
 static size_t active_workers(struct work_queue *workq)
 {
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	/* 
@@ -573,10 +574,10 @@
 static void signal_worker_op(struct work_queue *workq)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 
 	condvar_signal(&workq->activate_worker);
 	
 	irq_spinlock_lock(&workq->lock, true);
-	ASSERT(0 < workq->pending_op_cnt);
+	assert(0 < workq->pending_op_cnt);
 	--workq->pending_op_cnt;
 	irq_spinlock_unlock(&workq->lock, true);
@@ -593,6 +594,6 @@
 static signal_op_t signal_worker_logic(struct work_queue *workq, bool can_block)
 {
-	ASSERT(!workq_corrupted(workq));
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(!workq_corrupted(workq));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	/* Only signal workers if really necessary. */
@@ -645,5 +646,5 @@
 			 */
 			if (need_worker && !can_block && 0 == active) {
-				ASSERT(0 == workq->idle_worker_cnt);
+				assert(0 == workq->idle_worker_cnt);
 				
 				irq_spinlock_lock(&nonblock_adder.lock, true);
@@ -681,5 +682,5 @@
 	}
 	
-	ASSERT(arg != NULL);
+	assert(arg != NULL);
 	
 	struct work_queue *workq = arg;
@@ -697,5 +698,5 @@
 static bool dequeue_work(struct work_queue *workq, work_t **pwork_item)
 {
-	ASSERT(!workq_corrupted(workq));
+	assert(!workq_corrupted(workq));
 	
 	irq_spinlock_lock(&workq->lock, true);
@@ -704,5 +705,5 @@
 	if (!workq->stopping && worker_unnecessary(workq)) {
 		/* There are too many workers for this load. Exit. */
-		ASSERT(0 < workq->cur_worker_cnt);
+		assert(0 < workq->cur_worker_cnt);
 		--workq->cur_worker_cnt;
 		list_remove(&THREAD->workq_link);
@@ -729,5 +730,5 @@
 		
 #ifdef CONFIG_DEBUG
-		ASSERT(!work_item_corrupted(*pwork_item));
+		assert(!work_item_corrupted(*pwork_item));
 		(*pwork_item)->cookie = 0;
 #endif
@@ -738,5 +739,5 @@
 	} else {
 		/* Requested to stop and no more work queued. */
-		ASSERT(workq->stopping);
+		assert(workq->stopping);
 		--workq->cur_worker_cnt;
 		stop = true;
@@ -751,5 +752,5 @@
 static bool worker_unnecessary(struct work_queue *workq)
 {
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	/* No work is pending. We don't need too many idle threads. */
@@ -775,11 +776,11 @@
 	
 	/* Ignore lock ordering just here. */
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	_condvar_wait_timeout_irq_spinlock(&workq->activate_worker,
 		&workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
 
-	ASSERT(!workq_corrupted(workq));
-	ASSERT(irq_spinlock_locked(&workq->lock));
+	assert(!workq_corrupted(workq));
+	assert(irq_spinlock_locked(&workq->lock));
 	
 	THREAD->workq_idling = false;
@@ -791,14 +792,14 @@
 void workq_before_thread_is_ready(thread_t *thread)
 {
-	ASSERT(thread);
-	ASSERT(irq_spinlock_locked(&thread->lock));
+	assert(thread);
+	assert(irq_spinlock_locked(&thread->lock));
 
 	/* Worker's work func() is about to wake up from sleeping. */
 	if (thread->workq && thread->workq_blocked) {
 		/* Must be blocked in user work func() and not be waiting for work. */
-		ASSERT(!thread->workq_idling);
-		ASSERT(thread->state == Sleeping);
-		ASSERT(THREAD != thread);
-		ASSERT(!workq_corrupted(thread->workq));
+		assert(!thread->workq_idling);
+		assert(thread->state == Sleeping);
+		assert(THREAD != thread);
+		assert(!workq_corrupted(thread->workq));
 		
 		/* Protected by thread->lock */
@@ -814,11 +815,11 @@
 void workq_after_thread_ran(void)
 {
-	ASSERT(THREAD);
-	ASSERT(irq_spinlock_locked(&THREAD->lock));
+	assert(THREAD);
+	assert(irq_spinlock_locked(&THREAD->lock));
 
 	/* Worker's work func() is about to sleep/block. */
 	if (THREAD->workq && THREAD->state == Sleeping && !THREAD->workq_idling) {
-		ASSERT(!THREAD->workq_blocked);
-		ASSERT(!workq_corrupted(THREAD->workq));
+		assert(!THREAD->workq_blocked);
+		assert(!workq_corrupted(THREAD->workq));
 		
 		THREAD->workq_blocked = true;
@@ -834,5 +835,5 @@
 		
 		if (op) {
-			ASSERT(add_worker_noblock_op == op || signal_worker_op == op);
+			assert(add_worker_noblock_op == op || signal_worker_op == op);
 			op(THREAD->workq);
 		}
@@ -903,5 +904,5 @@
 			struct work_queue, nb_link);
 
-		ASSERT(!workq_corrupted(*pworkq));
+		assert(!workq_corrupted(*pworkq));
 		
 		list_remove(&(*pworkq)->nb_link);
Index: kernel/generic/src/syscall/copy.c
===================================================================
--- kernel/generic/src/syscall/copy.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/syscall/copy.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -39,4 +39,5 @@
  */
 
+#include <assert.h>
 #include <syscall/copy.h>
 #include <proc/thread.h>
@@ -63,6 +64,6 @@
 	int rc;
 	
-	ASSERT(THREAD);
-	ASSERT(!THREAD->in_copy_from_uspace);
+	assert(THREAD);
+	assert(!THREAD->in_copy_from_uspace);
 	
 	if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
@@ -114,6 +115,6 @@
 	int rc;
 	
-	ASSERT(THREAD);
-	ASSERT(!THREAD->in_copy_to_uspace);
+	assert(THREAD);
+	assert(!THREAD->in_copy_to_uspace);
 	
 	if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
Index: kernel/generic/src/sysinfo/stats.c
===================================================================
--- kernel/generic/src/sysinfo/stats.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/sysinfo/stats.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
  */
 
+#include <assert.h>
 #include <typedefs.h>
 #include <abi/sysinfo.h>
@@ -231,6 +232,6 @@
 static void produce_stats_task(task_t *task, stats_task_t *stats_task)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&task->lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&task->lock));
 	
 	stats_task->task_id = task->taskid;
@@ -333,6 +334,6 @@
 static void produce_stats_thread(thread_t *thread, stats_thread_t *stats_thread)
 {
-	ASSERT(interrupts_disabled());
-	ASSERT(irq_spinlock_locked(&thread->lock));
+	assert(interrupts_disabled());
+	assert(irq_spinlock_locked(&thread->lock));
 	
 	stats_thread->thread_id = thread->tid;
Index: kernel/generic/src/sysinfo/sysinfo.c
===================================================================
--- kernel/generic/src/sysinfo/sysinfo.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/sysinfo/sysinfo.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -34,4 +34,5 @@
  */
 
+#include <assert.h>
 #include <sysinfo/sysinfo.h>
 #include <mm/slab.h>
@@ -125,5 +126,5 @@
     sysinfo_item_t *subtree, sysinfo_return_t **ret, bool dry_run)
 {
-	ASSERT(subtree != NULL);
+	assert(subtree != NULL);
 	
 	sysinfo_item_t *cur = subtree;
@@ -191,5 +192,5 @@
     sysinfo_item_t **psubtree)
 {
-	ASSERT(psubtree != NULL);
+	assert(psubtree != NULL);
 	
 	if (*psubtree == NULL) {
@@ -204,9 +205,9 @@
 		*psubtree =
 		    (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
-		ASSERT(*psubtree);
+		assert(*psubtree);
 		
 		/* Fill in item name up to the delimiter */
 		(*psubtree)->name = str_ndup(name, i);
-		ASSERT((*psubtree)->name);
+		assert((*psubtree)->name);
 		
 		/* Create subtree items */
@@ -268,5 +269,5 @@
 			sysinfo_item_t *item =
 			    (sysinfo_item_t *) slab_alloc(sysinfo_item_slab, 0);
-			ASSERT(item);
+			assert(item);
 			
 			cur->next = item;
@@ -274,5 +275,5 @@
 			/* Fill in item name up to the delimiter */
 			item->name = str_ndup(name, i);
-			ASSERT(item->name);
+			assert(item->name);
 			
 			/* Create subtree items */
@@ -291,5 +292,5 @@
 	
 	/* Unreachable */
-	ASSERT(false);
+	assert(false);
 	return NULL;
 }
@@ -649,5 +650,5 @@
 	
 	char *path = (char *) malloc(size + 1, 0);
-	ASSERT(path);
+	assert(path);
 	
 	if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
@@ -760,5 +761,5 @@
 	
 	char *path = (char *) malloc(size + 1, 0);
-	ASSERT(path);
+	assert(path);
 	
 	if ((copy_from_uspace(path, ptr, size + 1) == 0) &&
Index: kernel/generic/src/udebug/udebug.c
===================================================================
--- kernel/generic/src/udebug/udebug.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/udebug/udebug.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,6 +38,7 @@
  */
 
+#include <assert.h>
+#include <debug.h>
 #include <synch/waitq.h>
-#include <debug.h>
 #include <udebug/udebug.h>
 #include <errno.h>
@@ -116,6 +117,6 @@
 void udebug_stoppable_begin(void)
 {
-	ASSERT(THREAD);
-	ASSERT(TASK);
+	assert(THREAD);
+	assert(TASK);
 	
 	mutex_lock(&TASK->udebug.lock);
@@ -125,5 +126,5 @@
 	/* Lock order OK, THREAD->udebug.lock is after TASK->udebug.lock */
 	mutex_lock(&THREAD->udebug.lock);
-	ASSERT(THREAD->udebug.stoppable == false);
+	assert(THREAD->udebug.stoppable == false);
 	THREAD->udebug.stoppable = true;
 	
@@ -136,5 +137,5 @@
 		
 		call_t *db_call = TASK->udebug.begin_call;
-		ASSERT(db_call);
+		assert(db_call);
 		
 		TASK->udebug.dt_state = UDEBUG_TS_ACTIVE;
@@ -158,5 +159,5 @@
 			call_t *go_call = THREAD->udebug.go_call;
 			THREAD->udebug.go_call = NULL;
-			ASSERT(go_call);
+			assert(go_call);
 			
 			IPC_SET_RETVAL(go_call->data, 0);
@@ -195,5 +196,5 @@
 	} else {
 		++TASK->udebug.not_stoppable_count;
-		ASSERT(THREAD->udebug.stoppable == true);
+		assert(THREAD->udebug.stoppable == true);
 		THREAD->udebug.stoppable = false;
 		
@@ -398,5 +399,5 @@
 int udebug_task_cleanup(struct task *task)
 {
-	ASSERT(mutex_locked(&task->udebug.lock));
+	assert(mutex_locked(&task->udebug.lock));
 
 	if ((task->udebug.dt_state != UDEBUG_TS_BEGINNING) &&
Index: kernel/generic/src/udebug/udebug_ipc.c
===================================================================
--- kernel/generic/src/udebug/udebug_ipc.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/generic/src/udebug/udebug_ipc.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -38,5 +38,6 @@
  * functions from the udebug_ops module which implement them.
  */
- 
+
+#include <assert.h>
 #include <proc/task.h>
 #include <proc/thread.h>
@@ -355,5 +356,5 @@
 	}
 
-	ASSERT(buffer != NULL);
+	assert(buffer != NULL);
 
 	/*
@@ -401,5 +402,5 @@
 	}
 
-	ASSERT(buffer != NULL);
+	assert(buffer != NULL);
 
 	IPC_SET_RETVAL(call->data, 0);
Index: kernel/test/cht/cht1.c
===================================================================
--- kernel/test/cht/cht1.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/test/cht/cht1.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -27,7 +27,7 @@
  */
 
+#include <assert.h>
 #include <test.h>
 #include <print.h>
-#include <debug.h>
 #include <adt/cht.h>
 #include <synch/rcu.h>
@@ -45,5 +45,5 @@
 {
 	val_t *v = member_to_inst(item, val_t, link);
-	ASSERT(v->hash == (v->unique_id % 10));
+	assert(v->hash == (v->unique_id % 10));
 	return v->hash;
 }
@@ -70,5 +70,5 @@
 {
 	val_t *v = member_to_inst(item, val_t, link);
-	ASSERT(!v->deleted);
+	assert(!v->deleted);
 	v->deleted = true;
 	free(v);
@@ -364,5 +364,5 @@
 {
 	stress_work_t *work = (stress_work_t *)arg;
-	ASSERT(0 == *work->stop);
+	assert(0 == *work->stop);
 	
 	size_t loops = 0;
@@ -528,5 +528,5 @@
 			thr[i] = thread_create(resize_stresser, &pwork[i], TASK, 0, "cht-resize");
 		
-		ASSERT(thr[i]);
+		assert(thr[i]);
 		thread_wire(thr[i], &cpus[i % config.cpu_active]);
 		thread_ready(thr[i]);
Index: kernel/test/smpcall/smpcall1.c
===================================================================
--- kernel/test/smpcall/smpcall1.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/test/smpcall/smpcall1.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -30,4 +30,5 @@
 #include <debug.h>
 
+#include <assert.h>
 #include <test.h>
 #include <smp/smp_call.h>
@@ -50,5 +51,5 @@
 static void inc(void *p)
 {
-	ASSERT(interrupts_disabled());
+	assert(interrupts_disabled());
 
 	size_t *pcall_cnt = (size_t*)p;
Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/test/synch/rcu1.c	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -27,4 +27,5 @@
  */
 
+#include <assert.h>
 #include <test.h>
 #include <arch.h>
@@ -81,5 +82,5 @@
 static void run_thread(size_t k, void (*func)(void*), void *arg)
 {
-	ASSERT(thread[k] == NULL);
+	assert(thread[k] == NULL);
 	
 	thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE, 
@@ -130,5 +131,5 @@
 static void run_one(void (*func)(void*), void *arg)
 {
-	ASSERT(one_idx < MAX_THREADS);
+	assert(one_idx < MAX_THREADS);
 	run_thread(one_idx, func, arg);
 	++one_idx;
@@ -138,5 +139,5 @@
 static void join_one(void)
 {
-	ASSERT(0 < one_idx && one_idx <= MAX_THREADS);
+	assert(0 < one_idx && one_idx <= MAX_THREADS);
 
 	--one_idx;
@@ -168,5 +169,5 @@
 static void get_seq(size_t from, size_t to, size_t steps, size_t *seq)
 {
-	ASSERT(0 < steps && from <= to && 0 < to);
+	assert(0 < steps && from <= to && 0 < to);
 	size_t inc = (to - from) / (steps - 1);
 	
@@ -304,5 +305,5 @@
 static void one_cb_done(rcu_item_t *item)
 {
-	ASSERT( ((item_w_cookie_t *)item)->cookie == magic_cookie);
+	assert( ((item_w_cookie_t *)item)->cookie == magic_cookie);
 	one_cb_is_done = 1;
 	TPRINTF("Callback()\n");
@@ -560,5 +561,5 @@
 {
 	preempt_t *p = (preempt_t*)arg;
-	ASSERT(!p->e.exited);
+	assert(!p->e.exited);
 
 	TPRINTF("reader_prev{ ");
@@ -580,5 +581,5 @@
 {
 	preempt_t *p = (preempt_t*)arg;
-	ASSERT(!p->e.exited);
+	assert(!p->e.exited);
 	
 	TPRINTF("reader_inside_cur{ ");
@@ -605,5 +606,5 @@
 {
 	preempt_t *p = (preempt_t*)arg;
-	ASSERT(!p->e.exited);
+	assert(!p->e.exited);
 	
 	TPRINTF("reader_cur{ ");
@@ -627,5 +628,5 @@
 {
 	preempt_t *p = (preempt_t*)arg;
-	ASSERT(!p->e.exited);
+	assert(!p->e.exited);
 	
 	TPRINTF("reader_next1{ ");
@@ -649,5 +650,5 @@
 {
 	preempt_t *p = (preempt_t*)arg;
-	ASSERT(!p->e.exited);
+	assert(!p->e.exited);
 	
 	TPRINTF("reader_next2{ ");
Index: kernel/test/synch/workq-test-core.h
===================================================================
--- kernel/test/synch/workq-test-core.h	(revision 7354b5e275cfd7f15773c38db318e1fa938eab6e)
+++ kernel/test/synch/workq-test-core.h	(revision 63e27efdf2fe6d3fa02bbb5ee1da00df5cc07e9d)
@@ -27,4 +27,5 @@
  */
 
+#include <assert.h>
 #include <test.h>
 #include <arch.h>
@@ -72,5 +73,5 @@
 {
 	test_work_t *child = malloc(sizeof(test_work_t), 0);
-	ASSERT(child);
+	assert(child);
 	if (child) {
 		child->master = false;