diff --git a/src/Reactor/Debug.cpp b/src/Reactor/Debug.cpp
index adfcabd..7f0d2cd 100644
--- a/src/Reactor/Debug.cpp
+++ b/src/Reactor/Debug.cpp
@@ -14,26 +14,61 @@
 
 #include "Debug.hpp"
 
-#include <stdio.h>
+#include <string>
 #include <stdarg.h>
 
 namespace rr
 {
-void trace(const char *format, ...)
+
+void tracev(const char *format, va_list args)
 {
+#ifndef RR_DISABLE_TRACE
 	if(false)
 	{
-		FILE *file = fopen("debug.txt", "a");
+		FILE *file = fopen(TRACE_OUTPUT_FILE, "a");
 
 		if(file)
 		{
-			va_list vararg;
-			va_start(vararg, format);
-			vfprintf(file, format, vararg);
-			va_end(vararg);
-
+			vfprintf(file, format, args);
 			fclose(file);
 		}
 	}
+#endif
 }
-}
\ No newline at end of file
+
+void trace(const char *format, ...)
+{
+	va_list vararg;
+	va_start(vararg, format);
+	tracev(format, vararg);
+	va_end(vararg);
+}
+
+void warn(const char *format, ...)
+{
+	va_list vararg;
+	va_start(vararg, format);
+	tracev(format, vararg);
+	va_end(vararg);
+
+	va_start(vararg, format);
+	vfprintf(stderr, format, vararg);
+	va_end(vararg);
+}
+
+void abort(const char *format, ...)
+{
+	va_list vararg;
+
+	va_start(vararg, format);
+	tracev(format, vararg);
+	va_end(vararg);
+
+	va_start(vararg, format);
+	vfprintf(stderr, format, vararg);
+	va_end(vararg);
+
+	::abort();
+}
+
+} // namespace rr
diff --git a/src/Reactor/Debug.hpp b/src/Reactor/Debug.hpp
index 9df0b38..d2b3a1f 100644
--- a/src/Reactor/Debug.hpp
+++ b/src/Reactor/Debug.hpp
@@ -12,41 +12,100 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef Debug_hpp
-#define Debug_hpp
+// debug.h: Debugging utilities.
 
-#if defined(__ANDROID__) && !defined(ANDROID_NDK_BUILD)
-#include "DebugAndroid.hpp"
-#else
+#ifndef rr_DEBUG_H_
+#define rr_DEBUG_H_
 
+#include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 
-#undef min
-#undef max
+#if !defined(TRACE_OUTPUT_FILE)
+#define TRACE_OUTPUT_FILE "debug.txt"
+#endif
 
 namespace rr
 {
-void trace(const char *format, ...);
+	// Outputs text to the debugging log
+	void trace(const char *format, ...);
+	inline void trace() {}
 
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
-	#define TRACE(format, ...) trace("[0x%0.8X]%s(" format ")\n", this, __FUNCTION__, ##__VA_ARGS__)
-#else
-	#define TRACE(...) ((void)0)
-#endif
+	// Outputs text to the debugging log and prints to stderr.
+	void warn(const char *format, ...);
+	inline void warn() {}
 
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
-	#define UNIMPLEMENTED() {trace("\t! Unimplemented: %s(%d)\n", __FUNCTION__, __LINE__); ASSERT(false);}
-#else
-	#define UNIMPLEMENTED() ((void)0)
-#endif
-
-#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
-	#define ASSERT(expression) {if(!(expression)) trace("\t! Assert failed in %s(%d): " #expression "\n", __FUNCTION__, __LINE__); assert(expression);}
-#else
-	#define ASSERT assert
-#endif
+	// Outputs the message to the debugging log and stderr, and calls abort().
+	void abort(const char *format, ...);
 }
 
-#endif   // __ANDROID__
-#endif   // Debug_hpp
+// A macro to output a trace of a function call and its arguments to the
+// debugging log. Disabled if RR_DISABLE_TRACE is defined.
+#if defined(RR_DISABLE_TRACE)
+#define TRACE(message, ...) (void(0))
+#else
+#define TRACE(message, ...) rr::trace("%s:%d TRACE: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#endif
+
+// A macro to print a warning message to the debugging log and stderr to denote
+// an issue that needs fixing.
+#define FIXME(message, ...) rr::warn("%s:%d FIXME: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__);
+
+// A macro to print a warning message to the debugging log and stderr.
+#define WARN(message, ...) rr::warn("%s:%d WARNING: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__);
+
+// A macro that prints the message to the debugging log and stderr and
+// immediately aborts execution of the application.
+//
+// Note: This will terminate the application regardless of build flags!
+//       Use with extreme caution!
+#undef ABORT
+#define ABORT(message, ...) rr::abort("%s:%d ABORT: " message "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+
+// A macro that delegates to:
+//   ABORT() in debug builds (!NDEBUG || DCHECK_ALWAYS_ON)
+// or
+//   WARN() in release builds (NDEBUG && !DCHECK_ALWAYS_ON)
+#undef DABORT
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define DABORT(message, ...) ABORT(message, ##__VA_ARGS__)
+#else
+#define DABORT(message, ...) WARN(message, ##__VA_ARGS__)
+#endif
+
+// A macro asserting a condition.
+// If the condition fails, the condition and message is passed to DABORT().
+#undef ASSERT_MSG
+#define ASSERT_MSG(expression, format, ...) do { \
+	if(!(expression)) { \
+		DABORT("ASSERT(%s): " format "\n", #expression, ##__VA_ARGS__); \
+	} } while(0)
+
+// A macro asserting a condition.
+// If the condition fails, the condition is passed to DABORT().
+#undef ASSERT
+#define ASSERT(expression) do { \
+	if(!(expression)) { \
+		DABORT("ASSERT(%s)\n", #expression); \
+	} } while(0)
+
+// A macro to indicate unimplemented functionality.
+#undef UNIMPLEMENTED
+#define UNIMPLEMENTED(format, ...) DABORT("UNIMPLEMENTED: " format, ##__VA_ARGS__)
+
+// A macro for code which is not expected to be reached under valid assumptions.
+#undef UNREACHABLE
+#define UNREACHABLE(format, ...) DABORT("UNREACHABLE: " format, ##__VA_ARGS__)
+
+// A macro asserting a condition and performing a return.
+#undef ASSERT_OR_RETURN
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+#define ASSERT_OR_RETURN(expression) ASSERT(expression)
+#else
+#define ASSERT_OR_RETURN(expression) do { \
+	if(!(expression)) { \
+		return; \
+	} } while(0)
+#endif
+
+#endif   // rr_DEBUG_H_
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 418e66d..2069a77 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "Reactor.hpp"
+#include "Debug.hpp"
 
 #include "x86.hpp"
 #include "CPUID.hpp"
@@ -92,7 +93,7 @@
 #if defined(__x86_64__) && defined(_WIN32)
 extern "C" void X86CompilationCallback()
 {
-	assert(false);   // UNIMPLEMENTED
+	UNIMPLEMENTED("X86CompilationCallback");
 }
 #endif
 
@@ -235,7 +236,7 @@
 		}
 		else
 		{
-			assert(numBits <= 64);
+			ASSERT_MSG(numBits <= 64, "numBits: %d", int(numBits));
 			uint64_t maxVal = (numBits == 64) ? ~0ULL : (1ULL << numBits) - 1;
 			max = llvm::ConstantInt::get(extTy, maxVal, false);
 			min = llvm::ConstantInt::get(extTy, 0, false);
@@ -361,7 +362,7 @@
 			llvm::cast<llvm::IntegerType>(dstTy->getElementType());
 
 		uint64_t truncNumBits = dstElemTy->getIntegerBitWidth();
-		assert(truncNumBits < 64 && "shift 64 must be handled separately");
+		ASSERT_MSG(truncNumBits < 64, "shift 64 must be handled separately. truncNumBits: %d", int(truncNumBits));
 		llvm::Constant *max, *min;
 		if (isSigned)
 		{
@@ -530,7 +531,7 @@
 					case SCCP:                 passManager->add(llvm::createSCCPPass());                 break;
 					case ScalarReplAggregates: passManager->add(llvm::createScalarReplAggregatesPass()); break;
 					default:
-						assert(false);
+						UNREACHABLE("optimization[pass]: %d, pass: %d", int(optimization[pass]), int(pass));
 					}
 				}
 			}
@@ -588,7 +589,8 @@
 			while (trimmed[0] == '_') { trimmed++; }
 
 			FunctionMap::const_iterator it = func_.find(trimmed);
-			assert(it != func_.end()); // Missing functions will likely make the module fail in exciting non-obvious ways.
+			// Missing functions will likely make the module fail in exciting non-obvious ways.
+			ASSERT_MSG(it != func_.end(), "Missing external function: '%s'", name.c_str());
 			return it->second;
 		}
 	};
@@ -713,7 +715,7 @@
 				case SCCP:                 passManager->add(llvm::createSCCPPass());                 break;
 				case ScalarReplAggregates: passManager->add(llvm::createSROAPass());                 break;
 				default:
-				                           assert(false);
+					UNREACHABLE("optimization[pass]: %d, pass: %d", int(optimization[pass]), int(pass));
 				}
 			}
 
@@ -773,7 +775,9 @@
 		case Type_v4i8:  return T(Byte16::getType());
 		case Type_v2f32: return T(Float4::getType());
 		case Type_LLVM:  return reinterpret_cast<llvm::Type*>(t);
-		default: assert(false); return nullptr;
+		default:
+			UNREACHABLE("asInternalType(t): %d", int(asInternalType(t)));
+			return nullptr;
 		}
 	}
 
@@ -833,7 +837,7 @@
 
 				// At this point we should only have LLVM 'primitive' types.
 				unsigned int bits = t->getPrimitiveSizeInBits();
-				assert(bits != 0);
+				ASSERT_MSG(bits != 0, "bits: %d", int(bits));
 
 				// TODO(capn): Booleans are 1 bit integers in LLVM's SSA type system,
 				// but are typically stored as one byte. The DataLayout structure should
@@ -842,7 +846,7 @@
 			}
 			break;
 		default:
-			assert(false);
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
 			return 0;
 		}
 	}
@@ -858,7 +862,9 @@
 		case Type_v4i8:  return 4;
 		case Type_v2f32: return 2;
 		case Type_LLVM:  return llvm::cast<llvm::VectorType>(T(type))->getNumElements();
-		default: assert(false); return 0;
+		default:
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return 0;
 		}
 	}
 
@@ -881,7 +887,9 @@
 		case std::memory_order_release: return llvm::AtomicOrdering::Release;
 		case std::memory_order_acq_rel: return llvm::AtomicOrdering::AcquireRelease;
 		case std::memory_order_seq_cst: return llvm::AtomicOrdering::SequentiallyConsistent;
-		default: assert(false);         return llvm::AtomicOrdering::AcquireRelease;
+		default:
+			UNREACHABLE("memoryOrder: %d", int(memoryOrder));
+			return llvm::AtomicOrdering::AcquireRelease;
 		}
 	}
 
@@ -1281,14 +1289,15 @@
 			// Fallthrough to non-emulated case.
 		case Type_LLVM:
 			{
-				assert(V(ptr)->getType()->getContainedType(0) == T(type));
+				ASSERT(V(ptr)->getType()->getContainedType(0) == T(type));
 				auto load = new llvm::LoadInst(V(ptr), "", isVolatile, alignment);
 				load->setAtomic(atomicOrdering(atomic, memoryOrder));
 
 				return V(::builder->Insert(load));
 			}
 		default:
-			assert(false); return nullptr;
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return nullptr;
 		}
 	}
 
@@ -1319,20 +1328,21 @@
 			// Fallthrough to non-emulated case.
 		case Type_LLVM:
 			{
-				assert(V(ptr)->getType()->getContainedType(0) == T(type));
+				ASSERT(V(ptr)->getType()->getContainedType(0) == T(type));
 				auto store = ::builder->Insert(new llvm::StoreInst(V(value), V(ptr), isVolatile, alignment));
 				store->setAtomic(atomicOrdering(atomic, memoryOrder));
 
 				return value;
 			}
 		default:
-			assert(false); return nullptr;
+			UNREACHABLE("asInternalType(type): %d", int(asInternalType(type)));
+			return nullptr;
 		}
 	}
 
 	Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index, bool unsignedIndex)
 	{
-		assert(V(ptr)->getType()->getContainedType(0) == T(type));
+		ASSERT(V(ptr)->getType()->getContainedType(0) == T(type));
 
 		if(sizeof(void*) == 8)
 		{
@@ -1559,7 +1569,7 @@
 
 	Value *Nucleus::createExtractElement(Value *vector, Type *type, int index)
 	{
-		assert(V(vector)->getType()->getContainedType(0) == T(type));
+		ASSERT(V(vector)->getType()->getContainedType(0) == T(type));
 		return V(::builder->CreateExtractElement(V(vector), V(createConstantInt(index))));
 	}
 
@@ -1573,7 +1583,7 @@
 		int size = llvm::cast<llvm::VectorType>(V(v1)->getType())->getNumElements();
 		const int maxSize = 16;
 		llvm::Constant *swizzle[maxSize];
-		assert(size <= maxSize);
+		ASSERT(size <= maxSize);
 
 		for(int i = 0; i < size; i++)
 		{
@@ -1668,10 +1678,10 @@
 
 	Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
 	{
-		assert(llvm::isa<llvm::VectorType>(T(type)));
+		ASSERT(llvm::isa<llvm::VectorType>(T(type)));
 		const int numConstants = elementCount(type);                                       // Number of provided constants for the (emulated) type.
 		const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();   // Number of elements of the underlying vector type.
-		assert(numElements <= 16 && numConstants <= numElements);
+		ASSERT(numElements <= 16 && numConstants <= numElements);
 		llvm::Constant *constantVector[16];
 
 		for(int i = 0; i < numElements; i++)
@@ -1684,10 +1694,10 @@
 
 	Value *Nucleus::createConstantVector(const double *constants, Type *type)
 	{
-		assert(llvm::isa<llvm::VectorType>(T(type)));
+		ASSERT(llvm::isa<llvm::VectorType>(T(type)));
 		const int numConstants = elementCount(type);                                       // Number of provided constants for the (emulated) type.
 		const int numElements = llvm::cast<llvm::VectorType>(T(type))->getNumElements();   // Number of elements of the underlying vector type.
-		assert(numElements <= 8 && numConstants <= numElements);
+		ASSERT(numElements <= 8 && numConstants <= numElements);
 		llvm::Constant *constantVector[8];
 
 		for(int i = 0; i < numElements; i++)
@@ -3217,7 +3227,7 @@
 	RValue<UInt4> Ctlz(RValue<UInt4> v, bool isZeroUndef)
 	{
 #if REACTOR_LLVM_VERSION < 7
-		assert(false); // TODO: LLVM 3 does not support ctlz in a vector form.
+		UNIMPLEMENTED("LLVM 3 does not support ctlz in a vector form");
 #endif
 		::llvm::SmallVector<::llvm::Type*, 2> paramTys;
 		paramTys.push_back(T(UInt4::getType()));
@@ -3232,7 +3242,7 @@
 	RValue<UInt4> Cttz(RValue<UInt4> v, bool isZeroUndef)
 	{
 #if REACTOR_LLVM_VERSION < 7
-		assert(false); // TODO: LLVM 3 does not support cttz in a vector form.
+		UNIMPLEMENTED("LLVM 3 does not support cttz in a vector form");
 #endif
 		::llvm::SmallVector<::llvm::Type*, 2> paramTys;
 		paramTys.push_back(T(UInt4::getType()));
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index 27604a8..63d7bd6 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "Reactor.hpp"
+#include "Debug.hpp"
 
 #include "Optimizer.hpp"
 #include "ExecutableMemory.hpp"
@@ -51,7 +52,6 @@
 #include <mutex>
 #include <limits>
 #include <iostream>
-#include <cassert>
 
 namespace
 {
@@ -191,7 +191,7 @@
 			case Type_v8i8:  return 8;
 			case Type_v4i8:  return 4;
 			case Type_v2f32: return 8;
-			default: assert(false);
+			default: ASSERT(false);
 			}
 		}
 
@@ -229,7 +229,7 @@
 			uint32_t symtab_entries = symbolTable->sh_size / symbolTable->sh_entsize;
 			if(index >= symtab_entries)
 			{
-				assert(index < symtab_entries && "Symbol Index out of range");
+				ASSERT(index < symtab_entries && "Symbol Index out of range");
 				return nullptr;
 			}
 
@@ -272,7 +272,7 @@
 				}
 				break;
 			default:
-				assert(false && "Unsupported relocation type");
+				ASSERT(false && "Unsupported relocation type");
 				return nullptr;
 			}
 		}
@@ -290,7 +290,7 @@
 		//		*patchSite = (int32_t)((intptr_t)symbolValue + *patchSite - (intptr_t)patchSite);
 		//		break;
 			default:
-				assert(false && "Unsupported relocation type");
+				ASSERT(false && "Unsupported relocation type");
 				return nullptr;
 			}
 		}
@@ -314,7 +314,7 @@
 			uint32_t symtab_entries = symbolTable->sh_size / symbolTable->sh_entsize;
 			if(index >= symtab_entries)
 			{
-				assert(index < symtab_entries && "Symbol Index out of range");
+				ASSERT(index < symtab_entries && "Symbol Index out of range");
 				return nullptr;
 			}
 
@@ -352,7 +352,7 @@
 			*patchSite32 = (int32_t)((intptr_t)symbolValue + *patchSite32 + relocation.r_addend);
 			break;
 		default:
-			assert(false && "Unsupported relocation type");
+			ASSERT(false && "Unsupported relocation type");
 			return nullptr;
 		}
 
@@ -369,17 +369,17 @@
 		}
 
 		// Expect ELF bitness to match platform
-		assert(sizeof(void*) == 8 ? elfHeader->getFileClass() == ELFCLASS64 : elfHeader->getFileClass() == ELFCLASS32);
+		ASSERT(sizeof(void*) == 8 ? elfHeader->getFileClass() == ELFCLASS64 : elfHeader->getFileClass() == ELFCLASS32);
 		#if defined(__i386__)
-			assert(sizeof(void*) == 4 && elfHeader->e_machine == EM_386);
+			ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_386);
 		#elif defined(__x86_64__)
-			assert(sizeof(void*) == 8 && elfHeader->e_machine == EM_X86_64);
+			ASSERT(sizeof(void*) == 8 && elfHeader->e_machine == EM_X86_64);
 		#elif defined(__arm__)
-			assert(sizeof(void*) == 4 && elfHeader->e_machine == EM_ARM);
+			ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_ARM);
 		#elif defined(__aarch64__)
-			assert(sizeof(void*) == 8 && elfHeader->e_machine == EM_AARCH64);
+			ASSERT(sizeof(void*) == 8 && elfHeader->e_machine == EM_AARCH64);
 		#elif defined(__mips__)
-			assert(sizeof(void*) == 4 && elfHeader->e_machine == EM_MIPS);
+			ASSERT(sizeof(void*) == 4 && elfHeader->e_machine == EM_MIPS);
 		#else
 			#error "Unsupported platform"
 		#endif
@@ -399,7 +399,7 @@
 			}
 			else if(sectionHeader[i].sh_type == SHT_REL)
 			{
-				assert(sizeof(void*) == 4 && "UNIMPLEMENTED");   // Only expected/implemented for 32-bit code
+				ASSERT(sizeof(void*) == 4 && "UNIMPLEMENTED");   // Only expected/implemented for 32-bit code
 
 				for(Elf32_Word index = 0; index < sectionHeader[i].sh_size / sectionHeader[i].sh_entsize; index++)
 				{
@@ -409,7 +409,7 @@
 			}
 			else if(sectionHeader[i].sh_type == SHT_RELA)
 			{
-				assert(sizeof(void*) == 8 && "UNIMPLEMENTED");   // Only expected/implemented for 64-bit code
+				ASSERT(sizeof(void*) == 8 && "UNIMPLEMENTED");   // Only expected/implemented for 64-bit code
 
 				for(Elf32_Word index = 0; index < sectionHeader[i].sh_size / sectionHeader[i].sh_entsize; index++)
 				{
@@ -477,7 +477,7 @@
 				buffer[position] = Value;
 				position++;
 			}
-			else assert(false && "UNIMPLEMENTED");
+			else ASSERT(false && "UNIMPLEMENTED");
 		}
 
 		void writeBytes(llvm::StringRef Bytes) override
@@ -590,7 +590,7 @@
 		optimize();
 
 		::function->translate();
-		assert(!::function->hasError());
+		ASSERT(!::function->hasError());
 
 		auto globals = ::function->getGlobalInits();
 
@@ -648,7 +648,7 @@
 
 	void Nucleus::setInsertBlock(BasicBlock *basicBlock)
 	{
-	//	assert(::basicBlock->getInsts().back().getTerminatorEdges().size() >= 0 && "Previous basic block must have a terminator");
+	//	ASSERT(::basicBlock->getInsts().back().getTerminatorEdges().size() >= 0 && "Previous basic block must have a terminator");
 
 		Variable::materializeAll();
 
@@ -734,7 +734,7 @@
 
 	static Value *createArithmetic(Ice::InstArithmetic::OpKind op, Value *lhs, Value *rhs)
 	{
-		assert(lhs->getType() == rhs->getType() || llvm::isa<Ice::Constant>(rhs));
+		ASSERT(lhs->getType() == rhs->getType() || llvm::isa<Ice::Constant>(rhs));
 
 		bool swapOperands = llvm::isa<Ice::Constant>(lhs) && isCommutative(op);
 
@@ -865,8 +865,8 @@
 
 	Value *Nucleus::createLoad(Value *ptr, Type *type, bool isVolatile, unsigned int align, bool atomic, std::memory_order memoryOrder)
 	{
-		assert(!atomic);  // Unimplemented
-		assert(memoryOrder == std::memory_order_relaxed);  // Unimplemented
+		ASSERT(!atomic);  // Unimplemented
+		ASSERT(memoryOrder == std::memory_order_relaxed);  // Unimplemented
 
 		int valueType = (int)reinterpret_cast<intptr_t>(type);
 		Ice::Variable *result = ::function->makeVariable(T(type));
@@ -899,7 +899,7 @@
 					auto bitcast = Ice::InstCast::create(::function, Ice::InstCast::Bitcast, result, vector.loadValue());
 					::basicBlock->appendInst(bitcast);
 				}
-				else assert(false);
+				else UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
 			}
 			else
 			{
@@ -922,8 +922,8 @@
 
 	Value *Nucleus::createStore(Value *value, Value *ptr, Type *type, bool isVolatile, unsigned int align, bool atomic, std::memory_order memoryOrder)
 	{
-		assert(!atomic);  // Unimplemented
-		assert(memoryOrder == std::memory_order_relaxed);  // Unimplemented
+		ASSERT(!atomic);  // Unimplemented
+		ASSERT(memoryOrder == std::memory_order_relaxed);  // Unimplemented
 
 		#if __has_feature(memory_sanitizer)
 			// Mark all (non-stack) memory writes as initialized by calling __msan_unpoison
@@ -968,7 +968,7 @@
 					Int y = Extract(v, 1);
 					*Pointer<Int>(pointer + 4) = y;
 				}
-				else assert(false);
+				else UNREACHABLE("typeSize(type): %d", int(typeSize(type)));
 			}
 			else
 			{
@@ -983,7 +983,7 @@
 		}
 		else
 		{
-			assert(value->getType() == T(type));
+			ASSERT(value->getType() == T(type));
 
 			auto store = Ice::InstStore::create(::function, value, ptr, align);
 			::basicBlock->appendInst(store);
@@ -994,7 +994,7 @@
 
 	Value *Nucleus::createGEP(Value *ptr, Type *type, Value *index, bool unsignedIndex)
 	{
-		assert(index->getType() == Ice::IceType_i32);
+		ASSERT(index->getType() == Ice::IceType_i32);
 
 		if(auto *constant = llvm::dyn_cast<Ice::ConstantInteger32>(index))
 		{
@@ -1030,7 +1030,8 @@
 
 	Value *Nucleus::createAtomicAdd(Value *ptr, Value *value)
 	{
-		assert(false && "UNIMPLEMENTED"); return nullptr;
+		UNIMPLEMENTED("createAtomicAdd");
+		return nullptr;
 	}
 
 	static Value *createCast(Ice::InstCast::OpKind op, Value *v, Type *destType)
@@ -1108,7 +1109,7 @@
 
 	static Value *createIntCompare(Ice::InstIcmp::ICond condition, Value *lhs, Value *rhs)
 	{
-		assert(lhs->getType() == rhs->getType());
+		ASSERT(lhs->getType() == rhs->getType());
 
 		auto result = ::function->makeVariable(Ice::isScalarIntegerType(lhs->getType()) ? Ice::IceType_i1 : lhs->getType());
 		auto cmp = Ice::InstIcmp::create(::function, condition, result, lhs, rhs);
@@ -1169,8 +1170,8 @@
 
 	static Value *createFloatCompare(Ice::InstFcmp::FCond condition, Value *lhs, Value *rhs)
 	{
-		assert(lhs->getType() == rhs->getType());
-		assert(Ice::isScalarFloatingType(lhs->getType()) || lhs->getType() == Ice::IceType_v4f32);
+		ASSERT(lhs->getType() == rhs->getType());
+		ASSERT(Ice::isScalarFloatingType(lhs->getType()) || lhs->getType() == Ice::IceType_v4f32);
 
 		auto result = ::function->makeVariable(Ice::isScalarFloatingType(lhs->getType()) ? Ice::IceType_i1 : Ice::IceType_v4i32);
 		auto cmp = Ice::InstFcmp::create(::function, condition, result, lhs, rhs);
@@ -1269,7 +1270,7 @@
 
 	Value *Nucleus::createShuffleVector(Value *V1, Value *V2, const int *select)
 	{
-		assert(V1->getType() == V2->getType());
+		ASSERT(V1->getType() == V2->getType());
 
 		int size = Ice::typeNumElements(V1->getType());
 		auto result = ::function->makeVariable(V1->getType());
@@ -1287,7 +1288,7 @@
 
 	Value *Nucleus::createSelect(Value *C, Value *ifTrue, Value *ifFalse)
 	{
-		assert(ifTrue->getType() == ifFalse->getType());
+		ASSERT(ifTrue->getType() == ifFalse->getType());
 
 		auto result = ::function->makeVariable(ifTrue->getType());
 		auto *select = Ice::InstSelect::create(::function, result, C, ifTrue, ifFalse);
@@ -1331,7 +1332,7 @@
 	{
 		if(Ice::isVectorType(T(Ty)))
 		{
-			assert(Ice::typeNumElements(T(Ty)) <= 16);
+			ASSERT(Ice::typeNumElements(T(Ty)) <= 16);
 			int64_t c[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 			return createConstantVector(c, Ty);
 		}
@@ -1394,7 +1395,7 @@
 	Value *Nucleus::createConstantVector(const int64_t *constants, Type *type)
 	{
 		const int vectorSize = 16;
-		assert(Ice::typeWidthInBytes(T(type)) == vectorSize);
+		ASSERT(Ice::typeWidthInBytes(T(type)) == vectorSize);
 		const int alignment = vectorSize;
 		auto globalPool = ::function->getGlobalPool();
 
@@ -1471,7 +1472,7 @@
 			}
 			break;
 		default:
-			assert(false && "Unknown constant vector type" && type);
+			UNREACHABLE("Unknown constant vector type: %d", (int)reinterpret_cast<intptr_t>(type));
 		}
 
 		auto name = Ice::GlobalString::createWithoutString(::context);
@@ -1839,7 +1840,7 @@
 
 	Short4::Short4(RValue<Float4> cast)
 	{
-		assert(false && "UNIMPLEMENTED");
+		UNIMPLEMENTED("Short4::Short4(RValue<Float4> cast)");
 	}
 
 	RValue<Short4> operator<<(RValue<Short4> lhs, unsigned char rhs)
@@ -2317,7 +2318,8 @@
 
 	RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y)
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<UShort4>(V(nullptr));
+		UNIMPLEMENTED("RValue<UShort4> Average(RValue<UShort4> x, RValue<UShort4> y)");
+		return UShort4(0);
 	}
 
 	Type *UShort4::getType()
@@ -2381,12 +2383,14 @@
 
 	RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y)
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<Int4>(V(nullptr));
+		UNIMPLEMENTED("RValue<Int4> MulAdd(RValue<Short8> x, RValue<Short8> y)");
+		return Int4(0);
 	}
 
 	RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y)
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<Short8>(V(nullptr));
+		UNIMPLEMENTED("RValue<Short8> MulHigh(RValue<Short8> x, RValue<Short8> y)");
+		return Short8(0);
 	}
 
 	Type *Short8::getType()
@@ -2450,18 +2454,20 @@
 
 	RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7)
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
+		UNIMPLEMENTED("RValue<UShort8> Swizzle(RValue<UShort8> x, char select0, char select1, char select2, char select3, char select4, char select5, char select6, char select7)");
+		return UShort8(0);
 	}
 
 	RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y)
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
+		UNIMPLEMENTED("RValue<UShort8> MulHigh(RValue<UShort8> x, RValue<UShort8> y)");
+		return UShort8(0);
 	}
 
 	// FIXME: Implement as Shuffle(x, y, Select(i0, ..., i16)) and Shuffle(x, y, SELECT_PACK_REPEAT(element))
 //	RValue<UShort8> PackRepeat(RValue<Byte16> x, RValue<Byte16> y, int element)
 //	{
-//		assert(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
+//		ASSERT(false && "UNIMPLEMENTED"); return RValue<UShort8>(V(nullptr));
 //	}
 
 	Type *UShort8::getType()
@@ -2569,7 +2575,7 @@
 
 //	RValue<UInt> RoundUInt(RValue<Float> cast)
 //	{
-//		assert(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
+//		ASSERT(false && "UNIMPLEMENTED"); return RValue<UInt>(V(nullptr));
 //	}
 
 	Type *UInt::getType()
@@ -3366,16 +3372,12 @@
 
 	RValue<Long> Ticks()
 	{
-		assert(false && "UNIMPLEMENTED"); return RValue<Long>(V(nullptr));
+		UNIMPLEMENTED("RValue<Long> Ticks()");
+		return Long(Int(0));
 	}
 
 	// Below are functions currently unimplemented for the Subzero backend.
 	// They are stubbed to satisfy the linker.
-	#ifdef UNIMPLEMENTED
-	#undef UNIMPLEMENTED
-	#endif
-	#define UNIMPLEMENTED(msg) assert(((void)(msg), false))
-
 	RValue<Float4> Sin(RValue<Float4> x) { UNIMPLEMENTED("Subzero Sin()"); return Float4(0); }
 	RValue<Float4> Cos(RValue<Float4> x) { UNIMPLEMENTED("Subzero Cos()"); return Float4(0); }
 	RValue<Float4> Tan(RValue<Float4> x) { UNIMPLEMENTED("Subzero Tan()"); return Float4(0); }