Clean up debug logging

[labath]

Summary

We've had two ways to print a "debug" log message.

• Log::GetDebug() was testing a Stream flag which was never set.
• Log::Debug() was checking for the presence of "log enable --debug"

flag.

Given that these two were used very rarely and we already have a
different way to specify "I want a more verbose log", I propose to remove
these two functions and migrate the callers to LLDB_LOGV. This commit
does that.

lldb/trunk/include/lldb/Core/Log.h

 #include <cstdint>
 // C Includes
 
 //----------------------------------------------------------------------
 // Logging Options
 //----------------------------------------------------------------------
 #define LLDB_LOG_OPTION_THREADSAFE (1u << 0)
 #define LLDB_LOG_OPTION_VERBOSE (1u << 1)
-#define LLDB_LOG_OPTION_DEBUG (1u << 2)
 #define LLDB_LOG_OPTION_PREPEND_SEQUENCE (1u << 3)
 #define LLDB_LOG_OPTION_PREPEND_TIMESTAMP (1u << 4)
 #define LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD (1u << 5)
 #define LLDB_LOG_OPTION_PREPEND_THREAD_NAME (1U << 6)
 #define LLDB_LOG_OPTION_BACKTRACE (1U << 7)
 #define LLDB_LOG_OPTION_APPEND (1U << 8)
 #define LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION (1U << 9)
 
public:
   // CLEANUP: Add llvm::raw_ostream &Stream() function.
   void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
   void VAPrintf(const char *format, va_list args);
 
   void LogIf(uint32_t mask, const char *fmt, ...)
       __attribute__((format(printf, 3, 4)));
 
-  void Debug(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
-
   void Error(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 
   void VAError(const char *format, va_list args);
 
   void Verbose(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 
   void Warning(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 
   Flags &GetOptions();
 
   const Flags &GetOptions() const;
 
   Flags &GetMask();
 
   const Flags &GetMask() const;
 
   bool GetVerbose() const;
 
-  bool GetDebug() const;
-
   void SetStream(const std::shared_ptr<llvm::raw_ostream> &stream_sp) {
     m_stream_sp = stream_sp;
   }
 
 protected:
   //------------------------------------------------------------------
   // Member variables
   //------------------------------------------------------------------

lldb/trunk/source/Commands/CommandObjectLog.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 static OptionDefinition g_log_options[] = {
     // clang-format off
   { LLDB_OPT_SET_1, false, "file",       'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Set the destination file to log to." },
   { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable thread safe logging to avoid interweaved log lines." },
   { LLDB_OPT_SET_1, false, "verbose",    'v', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable verbose logging." },
-  { LLDB_OPT_SET_1, false, "debug",      'g', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Enable debug logging." },
   { LLDB_OPT_SET_1, false, "sequence",   's', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with an increasing integer sequence id." },
   { LLDB_OPT_SET_1, false, "timestamp",  'T', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with a timestamp." },
   { LLDB_OPT_SET_1, false, "pid-tid",    'p', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the process and thread ID that generates the log line." },
   { LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Prepend all log lines with the thread name for the thread that generates the log line." },
   { LLDB_OPT_SET_1, false, "stack",      'S', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append a stack backtrace to each log line." },
   { LLDB_OPT_SET_1, false, "append",     'a', OptionParser::eNoArgument,       nullptr, nullptr, 0, eArgTypeNone,     "Append to the log file instead of overwriting." },
   { LLDB_OPT_SET_1, false, "file-function",'F',OptionParser::eNoArgument,      nullptr, nullptr, 0, eArgTypeNone,     "Prepend the names of files and function that generate the logs." },
     // clang-format on
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         log_file.SetFile(option_arg, true);
         break;
       case 't':
         log_options |= LLDB_LOG_OPTION_THREADSAFE;
         break;
       case 'v':
         log_options |= LLDB_LOG_OPTION_VERBOSE;
         break;
-      case 'g':
-        log_options |= LLDB_LOG_OPTION_DEBUG;
-        break;
       case 's':
         log_options |= LLDB_LOG_OPTION_PREPEND_SEQUENCE;
         break;
       case 'T':
         log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP;
         break;
       case 'p':
         log_options |= LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD;

lldb/trunk/source/Core/Log.cpp

void Log::VAPrintf(const char *format, va_list args) {
   free(text);
 
   message << "\n";
 
   WriteMessage(message.str());
 }
 
 //----------------------------------------------------------------------
-// Print debug strings if and only if the global debug option is set to
-// a non-zero value.
-//----------------------------------------------------------------------
-void Log::Debug(const char *format, ...) {
-  if (!GetOptions().Test(LLDB_LOG_OPTION_DEBUG))
-    return;
-
-  va_list args;
-  va_start(args, format);
-  VAPrintf(format, args);
-  va_end(args);
-}
-
-//----------------------------------------------------------------------
 // Log only if all of the bits are set
 //----------------------------------------------------------------------
 void Log::LogIf(uint32_t bits, const char *format, ...) {
   if (!m_options.AllSet(bits))
     return;
 
   va_list args;
   va_start(args, format);
for (idx = 0;
     LogChannelSP log_channel_sp(LogChannel::FindPlugin(name));
     if (log_channel_sp)
       log_channel_sp->ListCategories(strm);
   }
 }
 
 bool Log::GetVerbose() const { return m_options.Test(LLDB_LOG_OPTION_VERBOSE); }
 
-//------------------------------------------------------------------
-// Returns true if the debug flag bit is set in this stream.
-//------------------------------------------------------------------
-bool Log::GetDebug() const {
-  // TODO: remove and clean up callers
-  return false;
-}
-
 void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                       llvm::StringRef function) {
   static uint32_t g_sequence_id = 0;
   // Add a sequence ID if requested
   if (m_options.Test(LLDB_LOG_OPTION_PREPEND_SEQUENCE))
     OS << ++g_sequence_id << " ";
 
   // Timestamp if requested

lldb/trunk/source/Core/StringList.cpp

if (name)
     strm.Printf("Begin %s:\n", name);
   for (const auto &s : m_strings) {
     strm.Indent();
     strm.Printf("%s\n", s.c_str());
   }
   if (name)
     strm.Printf("End %s.\n", name);
 
-  log->Debug("%s", strm.GetData());
+  LLDB_LOGV(log, "{0}", strm.GetData());
 }

lldb/trunk/source/DataFormatters/FormatManager.cpp

if (match_data.GetTypeForCache()) {
     if (log)
       log->Printf(
           "\n\n[FormatManager::GetFormat] Looking into cache for type %s",
           match_data.GetTypeForCache().AsCString("<invalid>"));
     if (m_format_cache.GetFormat(match_data.GetTypeForCache(), retval)) {
       if (log) {
         log->Printf(
             "[FormatManager::GetFormat] Cache search success. Returning.");
-        if (log->GetDebug())
-          log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64
-                      " - Cache Misses: %" PRIu64,
-                      m_format_cache.GetCacheHits(),
-                      m_format_cache.GetCacheMisses());
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
       }
       return retval;
     }
     if (log)
       log->Printf(
           "[FormatManager::GetFormat] Cache search failed. Going normal route");
   }
 
FormatManager::GetFormat(ValueObject &valobj,
 
   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
     if (log)
       log->Printf("[FormatManager::GetFormat] Caching %p for type %s",
                   static_cast<void *>(retval.get()),
                   match_data.GetTypeForCache().AsCString("<invalid>"));
     m_format_cache.SetFormat(match_data.GetTypeForCache(), retval);
   }
-  if (log && log->GetDebug())
-    log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64
-                " - Cache Misses: %" PRIu64,
-                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
   return retval;
 }
 
 lldb::TypeSummaryImplSP
 FormatManager::GetHardcodedSummaryFormat(FormattersMatchData &match_data) {
   TypeSummaryImplSP retval_sp;
 
   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
if (match_data.GetTypeForCache()) {
     if (log)
       log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache "
                   "for type %s",
                   match_data.GetTypeForCache().AsCString("<invalid>"));
     if (m_format_cache.GetSummary(match_data.GetTypeForCache(), retval)) {
       if (log) {
         log->Printf("[FormatManager::GetSummaryFormat] Cache search success. "
                     "Returning.");
-        if (log->GetDebug())
-          log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64
-                      " - Cache Misses: %" PRIu64,
-                      m_format_cache.GetCacheHits(),
-                      m_format_cache.GetCacheMisses());
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
       }
       return retval;
     }
     if (log)
       log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. "
                   "Going normal route");
   }
 
FormatManager::GetSummaryFormat(ValueObject &valobj,
 
   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
     if (log)
       log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",
                   static_cast<void *>(retval.get()),
                   match_data.GetTypeForCache().AsCString("<invalid>"));
     m_format_cache.SetSummary(match_data.GetTypeForCache(), retval);
   }
-  if (log && log->GetDebug())
-    log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64
-                " - Cache Misses: %" PRIu64,
-                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
   return retval;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SyntheticChildrenSP
 FormatManager::GetHardcodedSyntheticChildren(FormattersMatchData &match_data) {
   SyntheticChildrenSP retval_sp;
 
if (match_data.GetTypeForCache()) {
     if (log)
       log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into "
                   "cache for type %s",
                   match_data.GetTypeForCache().AsCString("<invalid>"));
     if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), retval)) {
       if (log) {
         log->Printf("[FormatManager::GetSyntheticChildren] Cache search "
                     "success. Returning.");
-        if (log->GetDebug())
-          log->Printf(
-              "[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64
-              " - Cache Misses: %" PRIu64,
-              m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
+                  m_format_cache.GetCacheHits(),
+                  m_format_cache.GetCacheMisses());
       }
       return retval;
     }
     if (log)
       log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. "
                   "Going normal route");
   }
 
FormatManager::GetSyntheticChildren(ValueObject &valobj,
   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
     if (log)
       log->Printf(
           "[FormatManager::GetSyntheticChildren] Caching %p for type %s",
           static_cast<void *>(retval.get()),
           match_data.GetTypeForCache().AsCString("<invalid>"));
     m_format_cache.SetSynthetic(match_data.GetTypeForCache(), retval);
   }
-  if (log && log->GetDebug())
-    log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64
-                " - Cache Misses: %" PRIu64,
-                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
   return retval;
 }
 #endif
 
 lldb::TypeValidatorImplSP
 FormatManager::GetValidator(ValueObject &valobj,
                             lldb::DynamicValueType use_dynamic) {
   FormattersMatchData match_data(valobj, use_dynamic);
 
   TypeValidatorImplSP retval;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
   if (match_data.GetTypeForCache()) {
     if (log)
       log->Printf(
           "\n\n[FormatManager::GetValidator] Looking into cache for type %s",
           match_data.GetTypeForCache().AsCString("<invalid>"));
     if (m_format_cache.GetValidator(match_data.GetTypeForCache(), retval)) {
       if (log) {
         log->Printf(
             "[FormatManager::GetValidator] Cache search success. Returning.");
-        if (log->GetDebug())
-          log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64
-                      " - Cache Misses: %" PRIu64,
-                      m_format_cache.GetCacheHits(),
-                      m_format_cache.GetCacheMisses());
+        LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
       }
       return retval;
     }
     if (log)
       log->Printf("[FormatManager::GetValidator] Cache search failed. Going "
                   "normal route");
   }
 
FormatManager::GetValidator(ValueObject &valobj,
 
   if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
     if (log)
       log->Printf("[FormatManager::GetValidator] Caching %p for type %s",
                   static_cast<void *>(retval.get()),
                   match_data.GetTypeForCache().AsCString("<invalid>"));
     m_format_cache.SetValidator(match_data.GetTypeForCache(), retval);
   }
-  if (log && log->GetDebug())
-    log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64
-                " - Cache Misses: %" PRIu64,
-                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  LLDB_LOGV(log, "Cache hits: {0} - Cache Misses: {1}",
   return retval;
 }
 
 lldb::TypeValidatorImplSP
 FormatManager::GetHardcodedValidator(FormattersMatchData &match_data) {
   TypeValidatorImplSP retval_sp;
 
   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   // it for extra options.
   // For 99% of use cases, this will not be needed and should be provided when
   // basic platform detection is not enough.
   if (lang_rt)
     overridden_target_opts =
         lang_rt->GetOverrideExprOptions(m_compiler->getTargetOpts());
 
   if (overridden_target_opts)
-    if (log) {
-      log->Debug(
-          "Using overridden target options for the expression evaluation");
+    if (log && log->GetVerbose()) {
+      LLDB_LOGV(
+          log, "Using overridden target options for the expression evaluation");
 
       auto opts = m_compiler->getTargetOpts();
-      log->Debug("Triple: '%s'", opts.Triple.c_str());
-      log->Debug("CPU: '%s'", opts.CPU.c_str());
-      log->Debug("FPMath: '%s'", opts.FPMath.c_str());
-      log->Debug("ABI: '%s'", opts.ABI.c_str());
-      log->Debug("LinkerVersion: '%s'", opts.LinkerVersion.c_str());
+      LLDB_LOGV(log, "Triple: '{0}'", opts.Triple);
+      LLDB_LOGV(log, "CPU: '{0}'", opts.CPU);
+      LLDB_LOGV(log, "FPMath: '{0}'", opts.FPMath);
+      LLDB_LOGV(log, "ABI: '{0}'", opts.ABI);
+      LLDB_LOGV(log, "LinkerVersion: '{0}'", opts.LinkerVersion);
       StringList::LogDump(log, opts.FeaturesAsWritten, "FeaturesAsWritten");
       StringList::LogDump(log, opts.Features, "Features");
       StringList::LogDump(log, opts.Reciprocals, "Reciprocals");
     }
 
   // 4. Create and install the target on the compiler.
   m_compiler->createDiagnostics();
   auto target_info = TargetInfo::CreateTargetInfo(

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

for (auto line = info_lines.begin(); line != info_lines.end(); ++line) {
 
     const auto handler = rs_info_handler(key);
     if (handler == -1)
       continue;
     // getAsInteger returns `true` on an error condition - we're only interested
     // in numeric fields at the moment
     uint64_t n_lines;
     if (val.getAsInteger(10, n_lines)) {
-      if (log)
-        log->Debug("Failed to parse non-numeric '.rs.info' section %s",
-                   line->str().c_str());
+      LLDB_LOGV(log, "Failed to parse non-numeric '.rs.info' section {0}",
+                line->str());
       continue;
     }
     if (info_lines.end() - (line + 1) < (ptrdiff_t)n_lines)
       return false;
 
     bool success = false;
     switch (handler) {
     case eExportVar: