NullStream

base/logging.h

 // 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.
 
 #ifndef BASE_LOGGING_H_
 #define BASE_LOGGING_H_
 
 #include <stddef.h>
 
 #include <cassert>
@@ skipping 409 matching lines @@
   COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
       ::logging::GetLastSystemErrorCode()).stream()
 #endif
 
 #define PLOG(severity)                                          \
   LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
 
 #define PLOG_IF(severity, condition) \
   LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
 
-BASE_EXPORT extern std::ostream* g_swallow_stream;
+class NullStream {
+ public:
+  NullStream& stream() { return *this; }
+};
 
-// Note that g_swallow_stream is used instead of an arbitrary LOG() stream to
-// avoid the creation of an object with a non-trivial destructor (LogMessage).
-// On MSVC x86 (checked on 2015 Update 3), this causes a few additional
-// pointless instructions to be emitted even at full optimization level, even
-// though the : arm of the ternary operator is clearly never executed. Using a
-// simpler object to be &'d with Voidify() avoids these extra instructions.
-// Using a simpler POD object with a templated operator<< also works to avoid
-// these instructions. However, this causes warnings on statically defined
-// implementations of operator<<(std::ostream, ...) in some .cc files, because
-// they become defined-but-unreferenced functions. A reinterpret_cast of 0 to an
-// ostream* also is not suitable, because some compilers warn of undefined
-// behavior.
-#define EAT_STREAM_PARAMETERS \
-  true ? (void)0              \
-       : ::logging::LogMessageVoidify() & (*::logging::g_swallow_stream)
+template <typename T>
+inline NullStream& operator<<(NullStream& null_stream, const T&) {
+  return null_stream;
+}
+
+// std::endl compatibility
+inline NullStream& operator<<(NullStream& null_stream,
+                              std::ostream& (*)(std::ostream&)) {
+  return null_stream;
+}
 
 // Captures the result of a CHECK_EQ (for example) and facilitates testing as a
 // boolean.
 class CheckOpResult {
  public:
   // |message| must be non-null if and only if the check failed.
   CheckOpResult(std::string* message) : message_(message) {}
   // Returns true if the check succeeded.
   operator bool() const { return !message_; }
   // Returns the message.
@@ skipping 19 matching lines @@
 
 #if defined(OFFICIAL_BUILD) && defined(NDEBUG)
 
 // Make all CHECK functions discard their log strings to reduce code bloat, and
 // improve performance, for official release builds.
 //
 // This is not calling BreakDebugger since this is called frequently, and
 // calling an out-of-line function instead of a noreturn inline macro prevents
 // compiler optimizations.
 #define CHECK(condition) \
-  UNLIKELY(!(condition)) ? IMMEDIATE_CRASH() : EAT_STREAM_PARAMETERS
+  UNLIKELY(!(condition)) \
+  ? IMMEDIATE_CRASH()    \
+  : ::logging::LogMessageVoidify() & ::logging::NullStream().stream()
 
 #define PCHECK(condition) CHECK(condition)
 
 #define CHECK_OP(name, op, val1, val2) CHECK((val1) op (val2))
 
 #else  // !(OFFICIAL_BUILD && NDEBUG)
 
 #if defined(_PREFAST_) && defined(OS_WIN)
 // Use __analysis_assume to tell the VC++ static analysis engine that
 // assert conditions are true, to suppress warnings.  The LAZY_STREAM
@@ skipping 160 matching lines @@
 #define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
 #define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
 
 #else  // DCHECK_IS_ON()
 
 // If !DCHECK_IS_ON(), we want to avoid emitting any references to |condition|
 // (which may reference a variable defined only if DCHECK_IS_ON()).
 // Contrast this with DCHECK et al., which has different behavior.
 
 #define DLOG_IS_ON(severity) false
-#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
-#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
-#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
-#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
-#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+#define DLOG_IF(severity, condition) ::logging::NullStream().stream()
+#define DLOG_ASSERT(condition) ::logging::NullStream().stream()
+#define DPLOG_IF(severity, condition) ::logging::NullStream().stream()
+#define DVLOG_IF(verboselevel, condition) ::logging::NullStream().stream()
+#define DVPLOG_IF(verboselevel, condition) ::logging::NullStream().stream()
 
 #endif  // DCHECK_IS_ON()
 
 // DEBUG_MODE is for runtime uses like
 //   if (DEBUG_MODE) foo.CheckThatFoo();
 // We tie its state to DCHECK_IS_ON().
 //
 // For compile-time checks, #if DCHECK_IS_ON() can be used.
 enum { DEBUG_MODE = DCHECK_IS_ON() };
 
+#if DCHECK_IS_ON()
+
 #define DLOG(severity)                                          \
   LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
 
 #define DPLOG(severity)                                         \
   LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
 
 #define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
 
 #define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
 
-// Definitions for DCHECK et al.
-
-#if DCHECK_IS_ON()
-
-#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
-  COMPACT_GOOGLE_LOG_EX_FATAL(ClassName , ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_FATAL
-const LogSeverity LOG_DCHECK = LOG_FATAL;
-
 #else  // DCHECK_IS_ON()
 
-// These are just dummy values.
-#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
-  COMPACT_GOOGLE_LOG_EX_INFO(ClassName , ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_INFO
-const LogSeverity LOG_DCHECK = LOG_INFO;
+#define DLOG(severity) ::logging::NullStream().stream()
+#define DPLOG(severity) ::logging::NullStream().stream()
+#define DVLOG(verboselevel) ::logging::NullStream().stream()
+#define DVPLOG(verboselevel) ::logging::NullStream().stream()
 
-#endif  // DCHECK_IS_ON()
+#endif
+
+// Definitions for DCHECK et al.
 
 // DCHECK et al. make sure to reference |condition| regardless of
 // whether DCHECKs are enabled; this is so that we don't get unused
 // variable warnings if the only use of a variable is in a DCHECK.
 // This behavior is different from DLOG_IF et al.
 //
 // Note that the definition of the DCHECK macros depends on whether or not
 // DCHECK_IS_ON() is true. When DCHECK_IS_ON() is false, the macros use
-// EAT_STREAM_PARAMETERS to avoid expressions that would create temporaries.
+// NullStream() to reduce the number of expressions that create temporaries,
+// since the MSVC optimizer has trouble optimizing those temporaries away
+// completely.
 
 #if defined(_PREFAST_) && defined(OS_WIN)
 // See comments on the previous use of __analysis_assume.
 
 #define DCHECK(condition)                                               \
   __analysis_assume(!!(condition)),                                     \
   LAZY_STREAM(LOG_STREAM(DCHECK), false)                                \
   << "Check failed: " #condition ". "
 
 #define DPCHECK(condition)                                              \
   __analysis_assume(!!(condition)),                                     \
   LAZY_STREAM(PLOG_STREAM(DCHECK), false)                               \
   << "Check failed: " #condition ". "
 
 #else  // _PREFAST_
 
 #if DCHECK_IS_ON()
 
 #define DCHECK(condition)                       \
   LAZY_STREAM(LOG_STREAM(DCHECK), !(condition)) \
       << "Check failed: " #condition ". "
 #define DPCHECK(condition)                       \
   LAZY_STREAM(PLOG_STREAM(DCHECK), !(condition)) \
       << "Check failed: " #condition ". "
 
 #else  // DCHECK_IS_ON()
 
-#define DCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
-#define DPCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
+#define DCHECK(condition) \
+  LAZY_STREAM(::logging::NullStream().stream(), !(condition))
+#define DPCHECK(condition) \
+  LAZY_STREAM(::logging::NullStream().stream(), !(condition))
 
 #endif  // DCHECK_IS_ON()
 
 #endif  // _PREFAST_
 
 // Helper macro for binary operators.
 // Don't use this macro directly in your code, use DCHECK_EQ et al below.
 // The 'switch' is used to prevent the 'else' from being ambiguous when the
 // macro is used in an 'if' clause such as:
 // if (a == 1)
 //   DCHECK_EQ(2, a);
 #if DCHECK_IS_ON()
 
 #define DCHECK_OP(name, op, val1, val2)                                \
   switch (0) case 0: default:                                          \
   if (::logging::CheckOpResult true_if_passed =                        \
       DCHECK_IS_ON() ?                                                 \
       ::logging::Check##name##Impl((val1), (val2),                     \
                                    #val1 " " #op " " #val2) : nullptr) \
    ;                                                                   \
   else                                                                 \
     ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK,   \
                           true_if_passed.message()).stream()
 
 #else  // DCHECK_IS_ON()
 
-// When DCHECKs aren't enabled, DCHECK_OP still needs to reference operator<<
-// overloads for |val1| and |val2| to avoid potential compiler warnings about
-// unused functions. For the same reason, it also compares |val1| and |val2|
-// using |op|.
-//
-// Note that the contract of DCHECK_EQ, etc is that arguments are only evaluated
-// once. Even though |val1| and |val2| appear twice in this version of the macro
-// expansion, this is OK, since the expression is never actually evaluated.
-#define DCHECK_OP(name, op, val1, val2)                             \
-  EAT_STREAM_PARAMETERS << (::logging::MakeCheckOpValueString(      \
-                                ::logging::g_swallow_stream, val1), \
-                            ::logging::MakeCheckOpValueString(      \
-                                ::logging::g_swallow_stream, val2), \
-                            (val1)op(val2))
+#define DCHECK_OP(name, op, val1, val2) \
+  LAZY_STREAM(::logging::NullStream().stream(), !((val1)op(val2)))
 
 #endif  // DCHECK_IS_ON()
 
 // Equality/Inequality checks - compare two values, and log a
 // LOG_DCHECK message including the two values when the result is not
 // as expected.  The values must have operator<<(ostream, ...)
 // defined.
 //
 // You may append to the error message like so:
 //   DCHECK_NE(1, 2) << "The world must be ending!";
@@ skipping 16 matching lines @@
 #define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
 #define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
 #define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
 
 #if !DCHECK_IS_ON() && defined(OS_CHROMEOS)
 // Implement logging of NOTREACHED() as a dedicated function to get function
 // call overhead down to a minimum.
 void LogErrorNotReached(const char* file, int line);
 #define NOTREACHED()                                       \
   true ? ::logging::LogErrorNotReached(__FILE__, __LINE__) \
-       : EAT_STREAM_PARAMETERS
+       : ::logging::LogMessageVoidify() & ::logging::NullStream()
 #else
 #define NOTREACHED() DCHECK(false)
 #endif
 
 // Redefine the standard assert to use our nice log files
 #undef assert
 #define assert(x) DLOG_ASSERT(x)
 
 // This class more or less represents a particular log message.  You
 // create an instance of LogMessage and then stream stuff to it.
@@ skipping 58 matching lines @@
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(LogMessage);
 };
 
 // This class is used to explicitly ignore values in the conditional
 // logging macros.  This avoids compiler warnings like "value computed
 // is not used" and "statement has no effect".
 class LogMessageVoidify {
  public:
-  LogMessageVoidify() { }
   // This has to be an operator with a precedence lower than << but
   // higher than ?:
   void operator&(std::ostream&) { }
+  void operator&(NullStream&) {}
 };
 
 #if defined(OS_WIN)
 typedef unsigned long SystemErrorCode;
 #elif defined(OS_POSIX)
 typedef int SystemErrorCode;
 #endif
 
 // Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
 // pull in windows.h just for GetLastError() and DWORD.
@@ skipping 114 matching lines @@
 
 #if defined(COMPILER_GCC)
 // On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
 // of the current function in the NOTIMPLEMENTED message.
 #define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
 #else
 #define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
 #endif
 
 #if NOTIMPLEMENTED_POLICY == 0
-#define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS
+#define NOTIMPLEMENTED() ::logging::NullStream().stream()
 #elif NOTIMPLEMENTED_POLICY == 1
 // TODO, figure out how to generate a warning
 #define NOTIMPLEMENTED() static_assert(false, "NOT_IMPLEMENTED")
 #elif NOTIMPLEMENTED_POLICY == 2
 #define NOTIMPLEMENTED() static_assert(false, "NOT_IMPLEMENTED")
 #elif NOTIMPLEMENTED_POLICY == 3
 #define NOTIMPLEMENTED() NOTREACHED()
 #elif NOTIMPLEMENTED_POLICY == 4
 #define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
 #elif NOTIMPLEMENTED_POLICY == 5
-#define NOTIMPLEMENTED() do {\
-  static bool logged_once = false;\
-  LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
-  logged_once = true;\
-} while(0);\
-EAT_STREAM_PARAMETERS
+#define NOTIMPLEMENTED()                               \
+  do {                                                 \
+    static bool logged_once = false;                   \
+    LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
+    logged_once = true;                                \
+  } while (0);                                         \
+  ::logging::NullStream().stream()
 #endif
 
 #endif  // BASE_LOGGING_H_