diff --git a/src/class_linker.cc b/src/class_linker.cc
index 2cbac12..b480d87 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1911,7 +1911,7 @@
   }
   if (ifcount == 0) {
     // TODO: enable these asserts with klass status validation
-    // DCHECK(klass->GetIfTableCount() == 0);
+    // DCHECK_EQ(klass->GetIfTableCount(), 0);
     // DCHECK(klass->GetIfTable() == NULL);
     return true;
   }
diff --git a/src/compiler/Utility.cc b/src/compiler/Utility.cc
index b9fe050..0fc8a80 100644
--- a/src/compiler/Utility.cc
+++ b/src/compiler/Utility.cc
@@ -124,7 +124,7 @@
 /* Insert a new element into the growable list */
 void oatInsertGrowableList(GrowableList* gList, intptr_t elem)
 {
-    DCHECK(gList->numAllocated != 0);
+    DCHECK_NE(gList->numAllocated, 0U);
     if (gList->numUsed == gList->numAllocated) {
         expandGrowableList(gList);
     }
@@ -212,7 +212,7 @@
     ArenaBitVector* bv;
     unsigned int count;
 
-    DCHECK(sizeof(bv->storage[0]) == 4);        /* assuming 32-bit units */
+    DCHECK_EQ(sizeof(bv->storage[0]), 4U);        /* assuming 32-bit units */
 
     bv = (ArenaBitVector*) oatNew(sizeof(ArenaBitVector), false);
 
diff --git a/src/compiler/codegen/arm/ArchUtility.cc b/src/compiler/codegen/arm/ArchUtility.cc
index edce114..aef98fa 100644
--- a/src/compiler/codegen/arm/ArchUtility.cc
+++ b/src/compiler/codegen/arm/ArchUtility.cc
@@ -122,7 +122,7 @@
                 strcpy(tbuf, "!");
             } else {
                DCHECK_LT(fmt, fmtEnd);
-               DCHECK((unsigned)(nc-'0') < 4);
+               DCHECK_LT((unsigned)(nc-'0'), 4U);
                operand = lir->operands[nc-'0'];
                switch(*fmt++) {
                    case 'H':
diff --git a/src/compiler/codegen/arm/Thumb2/Factory.cc b/src/compiler/codegen/arm/Thumb2/Factory.cc
index 318be5a..1ea565a 100644
--- a/src/compiler/codegen/arm/Thumb2/Factory.cc
+++ b/src/compiler/codegen/arm/Thumb2/Factory.cc
@@ -341,7 +341,7 @@
             LOG(FATAL) << "Bad opcode: " << (int)op;
             break;
     }
-    DCHECK(opcode >= 0);
+    DCHECK_GE(static_cast<int>(opcode), 0);
     if (EncodingMap[opcode].flags & IS_BINARY_OP)
         return newLIR2(cUnit, opcode, rDestSrc1, rSrc2);
     else if (EncodingMap[opcode].flags & IS_TERTIARY_OP) {
@@ -418,7 +418,7 @@
             LOG(FATAL) << "Bad opcode: " << (int)op;
             break;
     }
-    DCHECK(opcode >= 0);
+    DCHECK_GE(static_cast<int>(opcode), 0);
     if (EncodingMap[opcode].flags & IS_QUAD_OP)
         return newLIR4(cUnit, opcode, rDest, rSrc1, rSrc2, shift);
     else {
diff --git a/src/dex_instruction_visitor.h b/src/dex_instruction_visitor.h
index 6a6bc3e..7b7704b 100644
--- a/src/dex_instruction_visitor.h
+++ b/src/dex_instruction_visitor.h
@@ -28,7 +28,7 @@
 #undef DEX_INSTRUCTION_LIST
 #undef INSTRUCTION_CASE
         default:
-          CHECK(true);
+          CHECK(false);
       }
       ptr += inst->Size() * sizeof(uint16_t);
       CHECK_LE(ptr, end);
diff --git a/src/logging.cc b/src/logging.cc
index 5e9ae3a..35a84ed 100644
--- a/src/logging.cc
+++ b/src/logging.cc
@@ -20,15 +20,13 @@
 #include "thread.h"
 #include "utils.h"
 
-namespace {
+namespace art {
 
 art::Mutex& GetLoggingLock() {
   static art::Mutex lock("LogMessage lock");
   return lock;
 }
 
-}
-
 LogMessage::~LogMessage() {
   // Finish constructing the message.
   if (errno_ != -1) {
@@ -62,3 +60,5 @@
 std::ostream& LogMessage::stream() {
   return buffer_;
 }
+
+}  // namespace art
diff --git a/src/logging.h b/src/logging.h
index 4abafdd..e358db6 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -26,19 +26,44 @@
 
 #define CHECK(x) \
   if (!(x)) \
-    LogMessage(__FILE__, __LINE__, FATAL, -1).stream() \
+    ::art::LogMessage(__FILE__, __LINE__, FATAL, -1).stream() \
         << "Check failed: " #x << " "
 
+namespace art {
+
+template <typename LHS, typename RHS>
+struct EagerEvaluator {
+  EagerEvaluator(LHS lhs, RHS rhs) : lhs(lhs), rhs(rhs) { }
+  LHS lhs;
+  RHS rhs;
+};
+
+
+class LogMessage {
+ public:
+  LogMessage(const char* file, int line, LogSeverity severity, int error);
+  ~LogMessage();
+  std::ostream& stream();
+
+ private:
+  void LogLine(const char*);
+
+  std::stringstream buffer_;
+  const char* file_;
+  int line_number_;
+  LogSeverity severity_;
+  int errno_;
+
+  DISALLOW_COPY_AND_ASSIGN(LogMessage);
+};
+
+}  // namespace art
+
 #define CHECK_OP(LHS, RHS, OP) \
-  do { \
-    typeof (LHS) _lhs = (LHS); \
-    typeof (RHS) _rhs = (RHS); \
-    if (!(_lhs OP _rhs)) { \
-      LogMessage(__FILE__, __LINE__, FATAL, -1).stream() \
-          << "Check failed: " << #LHS << " " << #OP << " " << #RHS \
-          << " (" #LHS "=" << _lhs << ", " #RHS "=" << _rhs << ")";  \
-    } \
-  } while (false)
+  for (::art::EagerEvaluator<typeof(LHS), typeof(RHS)> _values(LHS, RHS); !(_values.lhs OP _values.rhs); ) \
+    ::art::LogMessage(__FILE__, __LINE__, FATAL, -1).stream() \
+        << "Check failed: " << #LHS << " " << #OP << " " << #RHS \
+        << " (" #LHS "=" << _values.lhs << ", " #RHS "=" << _values.rhs << ") "
 
 #define CHECK_EQ(x, y) CHECK_OP(x, y, ==)
 #define CHECK_NE(x, y) CHECK_OP(x, y, !=)
@@ -48,14 +73,11 @@
 #define CHECK_GT(x, y) CHECK_OP(x, y, >)
 
 #define CHECK_STROP(s1, s2, sense) \
-  do { \
-    if ((strcmp(s1, s2) == 0) != sense) { \
-      LOG(FATAL) << "Check failed: " \
-                 << "\"" << s1 << "\"" \
-                 << (sense ? " == " : " != ") \
-                 << "\"" << s2 << "\""; \
-    } \
-  } while (false)
+  if ((strcmp(s1, s2) == 0) != sense) \
+    LOG(FATAL) << "Check failed: " \
+               << "\"" << s1 << "\"" \
+               << (sense ? " == " : " != ") \
+               << "\"" << s2 << "\""
 
 #define CHECK_STREQ(s1, s2) CHECK_STROP(s1, s2, true)
 #define CHECK_STRNE(s1, s2) CHECK_STROP(s1, s2, false)
@@ -121,29 +143,11 @@
 
 #endif
 
-#define LOG(severity) LogMessage(__FILE__, __LINE__, severity, -1).stream()
-#define PLOG(severity) LogMessage(__FILE__, __LINE__, severity, errno).stream()
+#define LOG(severity) ::art::LogMessage(__FILE__, __LINE__, severity, -1).stream()
+#define PLOG(severity) ::art::LogMessage(__FILE__, __LINE__, severity, errno).stream()
 
 #define LG LOG(INFO)
 
 #define UNIMPLEMENTED(level) LOG(level) << __PRETTY_FUNCTION__ << " unimplemented "
 
-class LogMessage {
- public:
-  LogMessage(const char* file, int line, LogSeverity severity, int error);
-  ~LogMessage();
-  std::ostream& stream();
-
- private:
-  void LogLine(const char*);
-
-  std::stringstream buffer_;
-  const char* file_;
-  int line_number_;
-  LogSeverity severity_;
-  int errno_;
-
-  DISALLOW_COPY_AND_ASSIGN(LogMessage);
-};
-
 #endif  // ART_SRC_LOGGING_H_
diff --git a/src/logging_android.cc b/src/logging_android.cc
index f404349..4e7a5fa 100644
--- a/src/logging_android.cc
+++ b/src/logging_android.cc
@@ -21,6 +21,8 @@
 
 #include "cutils/log.h"
 
+namespace art {
+
 static const int kLogSeverityToAndroidLogPriority[] = {
   ANDROID_LOG_INFO, ANDROID_LOG_WARN, ANDROID_LOG_ERROR, ANDROID_LOG_FATAL
 };
@@ -36,3 +38,5 @@
   int priority = kLogSeverityToAndroidLogPriority[severity_];
   LOG_PRI(priority, LOG_TAG, "%s:%d] %s", file_, line_number_, line);
 }
+
+}  // namespace art
diff --git a/src/logging_linux.cc b/src/logging_linux.cc
index fd12b98..d62649b 100644
--- a/src/logging_linux.cc
+++ b/src/logging_linux.cc
@@ -25,6 +25,8 @@
 #include "stringprintf.h"
 #include "utils.h"
 
+namespace art {
+
 LogMessage::LogMessage(const char* file, int line, LogSeverity severity, int error)
 : line_number_(line), severity_(severity), errno_(error)
 {
@@ -36,3 +38,5 @@
   std::cerr << "IWEF"[severity_] << ' ' << StringPrintf("%5d %5d", getpid(), ::art::GetTid()) << ' '
             << file_ << ':' << line_number_ << "] " << line << std::endl;
 }
+
+}  // namespace art
diff --git a/src/object.cc b/src/object.cc
index 99cdbc8..9f225d7 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -648,7 +648,7 @@
 uintptr_t Method::ToNativePC(const uint32_t dex_pc) const {
   const uint32_t* mapping_table = GetMappingTable();
   if (mapping_table == NULL) {
-    DCHECK(dex_pc == 0);
+    DCHECK_EQ(dex_pc, 0U);
     return 0;   // Special no mapping/pc == 0 case
   }
   size_t mapping_table_length = GetMappingTableLength();
diff --git a/src/object.h b/src/object.h
index de3075b..d8eb179 100644
--- a/src/object.h
+++ b/src/object.h
@@ -903,28 +903,26 @@
   }
 
   size_t GetFrameSizeInBytes() const {
-    DCHECK(sizeof(size_t) == sizeof(uint32_t));
-    size_t result = GetField32(
-        OFFSET_OF_OBJECT_MEMBER(Method, frame_size_in_bytes_), false);
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+    size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Method, frame_size_in_bytes_), false);
     DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
     return result;
   }
 
   void SetFrameSizeInBytes(size_t new_frame_size_in_bytes) {
-    DCHECK(sizeof(size_t) == sizeof(uint32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
     DCHECK_LE(static_cast<size_t>(kStackAlignment), new_frame_size_in_bytes);
     SetField32(OFFSET_OF_OBJECT_MEMBER(Method, frame_size_in_bytes_),
                new_frame_size_in_bytes, false);
   }
 
   size_t GetReturnPcOffsetInBytes() const {
-    DCHECK(sizeof(size_t) == sizeof(uint32_t));
-    return GetField32(
-        OFFSET_OF_OBJECT_MEMBER(Method, return_pc_offset_in_bytes_), false);
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+    return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, return_pc_offset_in_bytes_), false);
   }
 
   void SetReturnPcOffsetInBytes(size_t return_pc_offset_in_bytes) {
-    DCHECK(sizeof(size_t) == sizeof(uint32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
     DCHECK_LT(return_pc_offset_in_bytes, GetFrameSizeInBytes());
     SetField32(OFFSET_OF_OBJECT_MEMBER(Method, return_pc_offset_in_bytes_),
                return_pc_offset_in_bytes, false);
@@ -1321,9 +1319,8 @@
   };
 
   Status GetStatus() const {
-    CHECK(sizeof(Status) == sizeof(uint32_t));
-    return static_cast<Status>(
-        GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
+    DCHECK_EQ(sizeof(Status), sizeof(uint32_t));
+    return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
   }
 
   void SetStatus(Status new_status);
@@ -1429,13 +1426,13 @@
   }
 
   PrimitiveType GetPrimitiveType() const {
-    CHECK(sizeof(PrimitiveType) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(PrimitiveType), sizeof(int32_t));
     return static_cast<PrimitiveType>(
         GetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), false));
   }
 
   void SetPrimitiveType(PrimitiveType new_type) {
-    CHECK(sizeof(PrimitiveType) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(PrimitiveType), sizeof(int32_t));
     SetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), new_type, false);
   }
 
@@ -1527,26 +1524,23 @@
   }
 
   size_t SizeOf() const {
-    CHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
   }
 
   size_t GetClassSize() const {
-    CHECK(sizeof(size_t) == sizeof(uint32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
   }
 
   void SetClassSize(size_t new_class_size) {
-    DCHECK(new_class_size >= GetClassSize())
-            << " class=" << PrettyTypeOf(this)
-            << " new_class_size=" << new_class_size
-            << " GetClassSize=" << GetClassSize();
+    DCHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
     SetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size, false);
   }
 
   size_t GetObjectSize() const {
     CHECK(!IsVariableSize());
-    CHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), false);
     CHECK_GE(result, sizeof(Object));
     return result;
@@ -1554,7 +1548,7 @@
 
   void SetObjectSize(size_t new_object_size) {
     DCHECK(!IsVariableSize());
-    CHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size, false);
   }
 
@@ -1628,8 +1622,7 @@
     // Can only get super class for loaded classes (hack for when runtime is
     // initializing)
     DCHECK(IsLoaded() || !Runtime::Current()->IsStarted());
-    return GetFieldObject<Class*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
+    return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
   }
 
   static MemberOffset SuperClassOffset() {
@@ -1747,14 +1740,12 @@
 
   ObjectArray<Method>* GetVTable() const {
     DCHECK(IsResolved() || IsErroneous());
-    return GetFieldObject<ObjectArray<Method>*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+    return GetFieldObject<ObjectArray<Method>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
   }
 
   ObjectArray<Method>* GetVTableDuringLinking() const {
     DCHECK(IsLoaded() || IsErroneous());
-    return GetFieldObject<ObjectArray<Method>*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+    return GetFieldObject<ObjectArray<Method>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
   }
 
   void SetVTable(ObjectArray<Method>* new_vtable) {
@@ -1814,21 +1805,18 @@
 
   IntArray* GetInterfacesTypeIdx() const {
     CHECK(IsIdxLoaded() || IsErroneous());
-    return GetFieldObject<IntArray*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, interfaces_type_idx_), false);
+    return GetFieldObject<IntArray*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_type_idx_), false);
   }
 
   void SetInterfacesTypeIdx(IntArray* new_interfaces_idx);
 
   ObjectArray<Class>* GetInterfaces() const {
     CHECK(IsLoaded() || IsErroneous());
-    return GetFieldObject<ObjectArray<Class>*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false);
+    return GetFieldObject<ObjectArray<Class>*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false);
   }
 
   void SetInterfaces(ObjectArray<Class>* new_interfaces) {
-    DCHECK(NULL == GetFieldObject<Object*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false));
+    DCHECK(NULL == GetFieldObject<Object*>(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), false));
     SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, interfaces_), new_interfaces, false);
   }
 
@@ -1893,18 +1881,18 @@
   // Returns the number of instance fields containing reference types.
   size_t NumReferenceInstanceFields() const {
     DCHECK(IsResolved() || IsErroneous());
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
   }
 
   size_t NumReferenceInstanceFieldsDuringLinking() const {
     DCHECK(IsLoaded() || IsErroneous());
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
   }
 
   void SetNumReferenceInstanceFields(size_t new_num) {
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), new_num, false);
   }
 
@@ -1923,18 +1911,18 @@
   // Returns the number of static fields containing reference types.
   size_t NumReferenceStaticFields() const {
     DCHECK(IsResolved() || IsErroneous());
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
   }
 
   size_t NumReferenceStaticFieldsDuringLinking() const {
     DCHECK(IsLoaded() || IsErroneous());
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
   }
 
   void SetNumReferenceStaticFields(size_t new_num) {
-    DCHECK(sizeof(size_t) == sizeof(int32_t));
+    DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
     SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), new_num, false);
   }
 
@@ -2641,8 +2629,7 @@
 inline const String* Method::GetSignature() const {
   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
   const String* result =
-      GetFieldObject<const String*>(
-          OFFSET_OF_OBJECT_MEMBER(Method, signature_), false);
+      GetFieldObject<const String*>(OFFSET_OF_OBJECT_MEMBER(Method, signature_), false);
   DCHECK(result != NULL);
   return result;
 }
diff --git a/src/object_bitmap.cc b/src/object_bitmap.cc
index 06d86d6..483feac 100644
--- a/src/object_bitmap.cc
+++ b/src/object_bitmap.cc
@@ -111,7 +111,7 @@
 void HeapBitmap::ScanWalk(uintptr_t base, ScanCallback* callback, void* arg) {
   CHECK(words_ != NULL);
   CHECK(callback != NULL);
-  CHECK(base >= base_);
+  CHECK_GE(base, base_);
   uintptr_t end = HB_OFFSET_TO_INDEX(max_ - base);
   for (uintptr_t i = 0; i <= end; ++i) {
     unsigned long word = words_[i];
@@ -141,11 +141,11 @@
                            HeapBitmap::SweepCallback* callback, void* arg) {
   CHECK(live_bitmap.words_ != NULL);
   CHECK(mark_bitmap.words_ != NULL);
-  CHECK(live_bitmap.base_ == mark_bitmap.base_);
-  CHECK(live_bitmap.num_bytes_ == mark_bitmap.num_bytes_);
+  CHECK_EQ(live_bitmap.base_, mark_bitmap.base_);
+  CHECK_EQ(live_bitmap.num_bytes_, mark_bitmap.num_bytes_);
   CHECK(callback != NULL);
-  CHECK(base <= max);
-  CHECK(base >= live_bitmap.base_);
+  CHECK_LE(base, max);
+  CHECK_GE(base, live_bitmap.base_);
   max = std::min(max-1, live_bitmap.max_);
   if (live_bitmap.max_ < live_bitmap.base_) {
     // Easy case; both are obviously empty.
diff --git a/src/stack_walk.cc b/src/stack_walk.cc
index a1f6e0f..b2feee3 100644
--- a/src/stack_walk.cc
+++ b/src/stack_walk.cc
@@ -59,7 +59,7 @@
         EXPECT_EQ(0U, m->ToDexPC(pc));
         EXPECT_REGS(1);
       } else {
-        CHECK(gJava_StackWalk_refmap_calls == 2);
+        CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
         EXPECT_EQ(4U, m->ToDexPC(pc));
         EXPECT_REGS(1);  // Note that v1 is not in the minimal root set
       }
@@ -68,7 +68,7 @@
         EXPECT_EQ(0xaU, m->ToDexPC(pc));
         EXPECT_REGS(1, 2, 3);
       } else {
-        CHECK(gJava_StackWalk_refmap_calls == 2);
+        CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
         EXPECT_EQ(0xaU, m->ToDexPC(pc));
           EXPECT_REGS(1, 2, 3);
       }
@@ -77,7 +77,7 @@
         EXPECT_EQ(0x2d5U, m->ToDexPC(pc));
         EXPECT_REGS(2, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 25);
       } else {
-        CHECK(gJava_StackWalk_refmap_calls == 2);
+        CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
         EXPECT_EQ(0x2d5U, m->ToDexPC(pc));
         EXPECT_REGS(2, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 25);
       }
diff --git a/src/thread.cc b/src/thread.cc
index 5ffd451..b3dbcb6 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -698,7 +698,7 @@
       class_loader_override_(NULL),
       long_jump_context_(NULL),
       throwing_OOME_(false) {
-  CHECK((sizeof(Thread) % 4) == 0) << sizeof(Thread);
+  CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
 }
 
 void MonitorExitVisitor(const Object* object, void*) {
diff --git a/src/utils.cc b/src/utils.cc
index 03a4811..48ae2ae 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -203,8 +203,8 @@
 
   std::string class_name(declaring_class->GetDescriptor()->ToModifiedUtf8());
   // Remove the leading 'L' and trailing ';'...
-  CHECK(class_name[0] == 'L') << class_name;
-  CHECK(class_name[class_name.size() - 1] == ';') << class_name;
+  CHECK_EQ(class_name[0], 'L') << class_name;
+  CHECK_EQ(class_name[class_name.size() - 1], ';') << class_name;
   class_name.erase(0, 1);
   class_name.erase(class_name.size() - 1, 1);
 
diff --git a/src/zip_archive.cc b/src/zip_archive.cc
index 8c77391..82d97ec 100644
--- a/src/zip_archive.cc
+++ b/src/zip_archive.cc
@@ -222,7 +222,7 @@
     }
   } while (zerr == Z_OK);
 
-  DCHECK(zerr == Z_STREAM_END); // other errors should've been caught
+  DCHECK_EQ(zerr, Z_STREAM_END); // other errors should've been caught
 
   // paranoia
   if (zstream->Get().total_out != uncompressed_length) {