base: Remove the string logging from CHECK().

sandbox/linux/bpf_dsl/policy_compiler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/linux/bpf_dsl/policy_compiler.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/syscall.h>
@@ skipping 83 matching lines @@
       panic_func_(DefaultPanic),
       gen_(),
       has_unsafe_traps_(HasUnsafeTraps(policy_)) {
   DCHECK(policy);
 }
 
 PolicyCompiler::~PolicyCompiler() {
 }
 
 CodeGen::Program PolicyCompiler::Compile() {
-  CHECK(policy_->InvalidSyscall()->IsDeny())
-      << "Policies should deny invalid system calls";
+  // Policies should deny invalid system calls
+  CHECK(policy_->InvalidSyscall()->IsDeny());
 
   // If our BPF program has unsafe traps, enable support for them.
   if (has_unsafe_traps_) {
-    CHECK_NE(0U, escapepc_) << "UnsafeTrap() requires a valid escape PC";
+    // UnsafeTrap() requires a valid escape PC
+    CHECK_NE(0U, escapepc_);
 
     for (int sysnum : kSyscallsRequiredForUnsafeTraps) {
-      CHECK(policy_->EvaluateSyscall(sysnum)->IsAllow())
-          << "Policies that use UnsafeTrap() must unconditionally allow all "
-             "required system calls";
+      // Policies that use UnsafeTrap() must unconditionally allow all required
+      // system calls
+      CHECK(policy_->EvaluateSyscall(sysnum)->IsAllow());
     }
 
-    CHECK(registry_->EnableUnsafeTraps())
-        << "We'd rather die than enable unsafe traps";
+    // We'd rather die than enable unsafe traps
+    CHECK(registry_->EnableUnsafeTraps());
   }
 
   // Assemble the BPF filter program.
   return gen_.Compile(AssemblePolicy());
 }
 
 void PolicyCompiler::DangerousSetEscapePC(uint64_t escapepc) {
   escapepc_ = escapepc;
 }
 
@@ skipping 118 matching lines @@
   }
   ranges->push_back(Range{old_sysnum, old_node});
 }
 
 CodeGen::Node PolicyCompiler::AssembleJumpTable(Ranges::const_iterator start,
                                                 Ranges::const_iterator stop) {
   // We convert the list of system call ranges into jump table that performs
   // a binary search over the ranges.
   // As a sanity check, we need to have at least one distinct ranges for us
   // to be able to build a jump table.
-  CHECK(start < stop) << "Invalid iterator range";
+  // Invalid iterator range
+  CHECK(start < stop);
   const auto n = stop - start;
   if (n == 1) {
     // If we have narrowed things down to a single range object, we can
     // return from the BPF filter program.
     return start->node;
   }
 
   // Pick the range object that is located at the mid point of our list.
   // We compare our system call number against the lowest valid system call
   // number in this range object. If our number is lower, it is outside of
@@ skipping 10 matching lines @@
   return res->Compile(this);
 }
 
 CodeGen::Node PolicyCompiler::MaskedEqual(int argno,
                                           size_t width,
                                           uint64_t mask,
                                           uint64_t value,
                                           CodeGen::Node passed,
                                           CodeGen::Node failed) {
   // Sanity check that arguments make sense.
-  CHECK(argno >= 0 && argno < 6) << "Invalid argument number " << argno;
-  CHECK(width == 4 || width == 8) << "Invalid argument width " << width;
-  CHECK_NE(0U, mask) << "Zero mask is invalid";
-  CHECK_EQ(value, value & mask) << "Value contains masked out bits";
+  // Invalid argument number |argno|
+  CHECK(argno >= 0 && argno < 6);
+  // Invalid argument width |width|
+  CHECK(width == 4 || width == 8);
+  // Zero mask is invalid
+  CHECK_NE(0U, mask);
+  // Value contains masked out bits
+  CHECK_EQ(value, value & mask);
   if (sizeof(void*) == 4) {
-    CHECK_EQ(4U, width) << "Invalid width on 32-bit platform";
+    // Invalid width on 32-bit platform
+    CHECK_EQ(4U, width);
   }
   if (width == 4) {
-    CHECK_EQ(0U, mask >> 32) << "Mask exceeds argument size";
-    CHECK_EQ(0U, value >> 32) << "Value exceeds argument size";
+    // Mask exceeds argument size
+    CHECK_EQ(0U, mask >> 32);
+    // Value exceeds argument size
+    CHECK_EQ(0U, value >> 32);
   }
 
   // We want to emit code to check "(arg & mask) == value" where arg, mask, and
   // value are 64-bit values, but the BPF machine is only 32-bit. We implement
   // this by independently testing the upper and lower 32-bits and continuing to
   // |passed| if both evaluate true, or to |failed| if either evaluate false.
   return MaskedEqualHalf(argno, width, mask, value, ArgHalf::UPPER,
                          MaskedEqualHalf(argno, width, mask, value,
                                          ArgHalf::LOWER, passed, failed),
                          failed);
@@ skipping 149 matching lines @@
   for (size_t i = 0; i < arraysize(kSyscallsRequiredForUnsafeTraps); ++i) {
     if (sysno == kSyscallsRequiredForUnsafeTraps[i]) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace bpf_dsl
 }  // namespace sandbox