Remove LIBLLDB_LOG_VERBOSE category

[labath]

Summary

Per discussion in D28616, having two ways two request logging (log
enable lldb XXX verbose && log enable -v lldb XXX) is confusing. This
removes the first option and standardizes all code to use the second
one.

I've added a LLDB_LOGV macro as a shorthand for if(log &&
log->GetVerbose()) and switched most of the affected log statements to
use that (I've only left a couple of cases that were doing complex
computations in an if(log) block).

[labath]

Adding greg in case he has some thoughts on this as well.

[clayborg]

Looks good.

[zturner]

source/Target/SectionLoadList.cpp

70 ↗

(On Diff #87006)

There's a subtle behavioral change here, which is that previously this line would get logged even if LIBLLDB_LOG_DYNAMIC_LOADER was not set, and now it won't. However, I've always found the GetLogIfAny / GetLogIfAll split unnecessarily confusing, so I'm not opposed to this change. Just want to point it out.

76 ↗

(On Diff #87006)

No need to call AsCString().

[jingham]

Thanks for taking the trouble to clean that up, that's lovely!

[labath]

source/Target/SectionLoadList.cpp

70 ↗

(On Diff #87006)

You're right I didn't notice that. However, I suspect that this was actually not intended, so it should be fine. It'd be interesting to see how many calls to IfAny/IfAll we have with more than one category after this change.

76 ↗

(On Diff #87006)

We don't have a formatter for ConstString yet. I'll interpret this as a request to add one.

[clayborg]

source/Target/SectionLoadList.cpp

70 ↗

(On Diff #87006)

The previous usage was incorrect indeed. It should have been IfAll. IfAny only works when you might have something that should be logged for say "process" or for "thread". Then IfAny makes sense. Never makes sense to use IfAny with one any flag and verbose...

[jingham]

This is sort of a side question, but Pavel's comment brought it up. If I were new to this stuff, and wanted to know which entities had formatters and which didn't, how would I find that out easily? There are a couple of Format calls that use it, maybe they should have some doc that references where the built-in formatters are?

[jingham]

Oh, yeah, and I should remember to check okay...

[zturner]

In D29510#666443, @jingham wrote:

This is sort of a side question, but Pavel's comment brought it up. If I were new to this stuff, and wanted to know which entities had formatters and which didn't, how would I find that out easily? There are a couple of Format calls that use it, maybe they should have some doc that references where the built-in formatters are?

A couple ideas come to mind.

1. Try it and see if it compiles. This won't tell you if a formatter exists and you didn't include the right header for it, though. Although if the formatter is always defined in the same header file that the object itself is defined in, this wouldn't be a problem.
2. Grep the codebase for format_provider and FormatAdapter

[labath]

Add ConstString formatter and use it.

[jingham]

That's kind of a Meno response... How would I know to look for them if I don't know they are there. These format strings are only used in a couple of places. Those calls should tell me that I CAN use these format strings and where/how to find them.

[zturner]

I guess the same way you would know how to use any part of a library or API. The first time you've ever used an API, you don't know how it works, so you don't know it's capabilities. So you fiddle around, read the source code, trudge through some compiler errors, then you learned some more about how it works. Probably someone using this would try to print something, and get a compiler error that triggers a helpful static_assert which says "missing format provider for type = Foo!". That gives them the next piece of the puzzle they need to understand a little bit more. Or they look at the code for formatv to see how it works and see all the documentation.

It sounds analogous to asking "how does someone new to the codebase know that commands in LLDB are implemented by something which inherits from CommandObject?". Of course you don't if you're brand new, but once you figure it out you don't really have to spend much time thinking about it again.

[zturner]

FWIW, long term I would like to get rid of ALL printf style formatting. So right now, yes, they are only used in a few places. But it would be nice if it were the only type of formatting used anywhere. At which point I think most of your questions would be resolved on their own.

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

 
 #define LLDB_LOG(log, ...)                                                     \
   do {                                                                         \
     ::lldb_private::Log *log_private = (log);                                  \
     if (log_private)                                                           \
       log_private->Format(__FILE__, __FUNCTION__, __VA_ARGS__);                \
   } while (0)
 
+#define LLDB_LOGV(log, ...)                                                    \
+  do {                                                                         \
+    ::lldb_private::Log *log_private = (log);                                  \
+    if (log_private && log_private->GetVerbose())                              \
+      log_private->Format(__FILE__, __FUNCTION__, __VA_ARGS__);                \
+  } while (0)
+
 #endif // liblldb_Log_h_

lldb/trunk/include/lldb/Core/Logging.h

 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 
 //----------------------------------------------------------------------
 // Log Bits specific to logging in lldb
 //----------------------------------------------------------------------
-#define LIBLLDB_LOG_VERBOSE (1u << 0)
 #define LIBLLDB_LOG_PROCESS (1u << 1)
 #define LIBLLDB_LOG_THREAD (1u << 2)
 #define LIBLLDB_LOG_DYNAMIC_LOADER (1u << 3)
 #define LIBLLDB_LOG_EVENTS (1u << 4)
 #define LIBLLDB_LOG_BREAKPOINTS (1u << 5)
 #define LIBLLDB_LOG_WATCHPOINTS (1u << 6)
 #define LIBLLDB_LOG_STEP (1u << 7)
 #define LIBLLDB_LOG_EXPRESSIONS (1u << 8)

 void LogIfAnyCategoriesSet(uint32_t mask, const char *format, ...);
 
 Log *GetLogIfAllCategoriesSet(uint32_t mask);
 
 Log *GetLogIfAnyCategoriesSet(uint32_t mask);
 
 uint32_t GetLogMask();
 
-bool IsLogVerbose();
-
 void DisableLog(const char **categories, Stream *feedback_strm);
 
 Log *EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options,
                const char **categories, Stream *feedback_strm);
 
 void ListLogCategories(Stream *strm);
 
 } // namespace lldb_private
 
 #endif // liblldb_Core_Logging_h_

lldb/trunk/include/lldb/Utility/ConstString.h

 
 //------------------------------------------------------------------
 /// Stream the string value \a str to the stream \a s
 //------------------------------------------------------------------
 Stream &operator<<(Stream &s, const ConstString &str);
 
 } // namespace lldb_private
 
+namespace llvm {
+template <> struct format_provider<lldb_private::ConstString> {
+  static void format(const lldb_private::ConstString &CS, llvm::raw_ostream &OS,
+                     llvm::StringRef Options);
+};
+}
+
 #endif // liblldb_ConstString_h_

lldb/trunk/source/API/SBBroadcaster.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {}
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
   m_opaque_ptr = m_opaque_sp.get();
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API |
-                                                  LIBLLDB_LOG_VERBOSE));
-
-  if (log)
-    log->Printf(
-        "SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)", name,
-        static_cast<void *>(m_opaque_ptr));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
     : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API |
-                                                  LIBLLDB_LOG_VERBOSE));
-
-  if (log)
-    log->Printf("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) "
-                "=> SBBroadcaster(%p)",
-                static_cast<void *>(broadcaster), owns,
-                static_cast<void *>(m_opaque_ptr));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})",
+            broadcaster, owns, m_opaque_ptr);
 }
 
 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
 
 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;

lldb/trunk/source/API/SBEvent.cpp

bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
 
   Event *lldb_event = get();
   bool success = false;
   if (lldb_event)
     success = lldb_event->BroadcasterIs(broadcaster.get());
 
   // For logging, this gets a little chatty so only enable this when verbose
   // logging is on
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API |
-                                                  LIBLLDB_LOG_VERBOSE));
-  if (log)
-    log->Printf(
-        "SBEvent(%p)::BroadcasterMatchesRef (SBBroadcaster(%p): %s) => %i",
-        static_cast<void *>(get()), static_cast<void *>(broadcaster.get()),
-        broadcaster.GetName(), success);
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(),
+            broadcaster.get(), broadcaster.GetName(), success);
 
   return success;
 }
 
 void SBEvent::Clear() {
   Event *lldb_event = get();
   if (lldb_event)
     lldb_event->Clear();

lldb/trunk/source/Core/DataBufferMemoryMap.cpp

 //----------------------------------------------------------------------
 size_t DataBufferMemoryMap::MemoryMapFromFileDescriptor(int fd,
                                                         lldb::offset_t offset,
                                                         size_t length,
                                                         bool writeable,
                                                         bool fd_is_file) {
   Clear();
   if (fd >= 0) {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MMAP |
-                                                    LIBLLDB_LOG_VERBOSE));
-    if (log) {
-      log->Printf("DataBufferMemoryMap::MemoryMapFromFileDescriptor(fd=%i, "
-                  "offset=0x%" PRIx64 ", length=0x%" PRIx64
-                  ", writeable=%i, fd_is_file=%i)",
-                  fd, offset, (uint64_t)length, writeable, fd_is_file);
-    }
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MMAP));
+    LLDB_LOGV(log,
+              "(fd={0}, offset={1:x}, length={2:x}, "
+              "writeable={3}, fd_is_file={4})",
+              fd, offset, length, writeable, fd_is_file);
 #ifdef _WIN32
     HANDLE handle = (HANDLE)_get_osfhandle(fd);
     DWORD file_size_low, file_size_high;
     file_size_low = GetFileSize(handle, &file_size_high);
     const lldb::offset_t file_size =
         llvm::Make_64(file_size_high, file_size_low);
     const lldb::offset_t max_bytes_available = file_size - offset;
     const size_t max_bytes_mappable =
if (::fstat(fd, &stat) == 0) {
             }
           } else {
             // We were able to map the requested data in one chunk
             // where our mmap and actual data are the same.
             m_mmap_size = length;
             m_data = m_mmap_addr;
             m_size = length;
           }
-
-          if (log) {
-            log->Printf(
-                "DataBufferMemoryMap::MemoryMapFromFileSpec() m_mmap_addr = "
-                "%p, m_mmap_size = %" PRIu64 ", error = %s",
-                (void *)m_mmap_addr, (uint64_t)m_mmap_size, error.AsCString());
-          }
+          LLDB_LOGV(log, "m_mmap_addr = {0}, m_mmap_size = {1}, error = {2}",
+                    m_mmap_addr, m_mmap_size, error);
         }
       }
     }
 #endif
   }
   return GetByteSize();
 }

lldb/trunk/source/Core/Logging.cpp

 
 uint32_t lldb_private::GetLogMask() {
   Log *log(GetLog());
   if (log)
     return log->GetMask().Get();
   return 0;
 }
 
-bool lldb_private::IsLogVerbose() {
-  uint32_t mask = GetLogMask();
-  return (mask & LIBLLDB_LOG_VERBOSE);
-}
-
 Log *lldb_private::GetLogIfAllCategoriesSet(uint32_t mask) {
   Log *log(GetLog());
   if (log && mask) {
     uint32_t log_mask = log->GetMask().Get();
     if ((log_mask & mask) != mask)
       return nullptr;
   }
   return log;
if (categories && categories[0]) {
         else if (0 == ::strcasecmp(arg, "state"))
           flag_bits &= ~LIBLLDB_LOG_STATE;
         else if (0 == ::strcasecmp(arg, "step"))
           flag_bits &= ~LIBLLDB_LOG_STEP;
         else if (0 == ::strcasecmp(arg, "thread"))
           flag_bits &= ~LIBLLDB_LOG_THREAD;
         else if (0 == ::strcasecmp(arg, "target"))
           flag_bits &= ~LIBLLDB_LOG_TARGET;
-        else if (0 == ::strcasecmp(arg, "verbose"))
-          flag_bits &= ~LIBLLDB_LOG_VERBOSE;
         else if (0 == ::strncasecmp(arg, "watch", 5))
           flag_bits &= ~LIBLLDB_LOG_WATCHPOINTS;
         else if (0 == ::strncasecmp(arg, "temp", 4))
           flag_bits &= ~LIBLLDB_LOG_TEMPORARY;
         else if (0 == ::strncasecmp(arg, "comm", 4))
           flag_bits &= ~LIBLLDB_LOG_COMMUNICATION;
         else if (0 == ::strncasecmp(arg, "conn", 4))
           flag_bits &= ~LIBLLDB_LOG_CONNECTION;
for (size_t i = 0; categories[i] != nullptr; ++i) {
       else if (0 == ::strncasecmp(arg, "temp", 4))
         flag_bits |= LIBLLDB_LOG_TEMPORARY;
       else if (0 == ::strcasecmp(arg, "thread"))
         flag_bits |= LIBLLDB_LOG_THREAD;
       else if (0 == ::strncasecmp(arg, "types", 5))
         flag_bits |= LIBLLDB_LOG_TYPES;
       else if (0 == ::strncasecmp(arg, "unwind", 6))
         flag_bits |= LIBLLDB_LOG_UNWIND;
-      else if (0 == ::strcasecmp(arg, "verbose"))
-        flag_bits |= LIBLLDB_LOG_VERBOSE;
       else if (0 == ::strncasecmp(arg, "watch", 5))
         flag_bits |= LIBLLDB_LOG_WATCHPOINTS;
       else if (0 == ::strcasecmp(arg, "jit"))
         flag_bits |= LIBLLDB_LOG_JIT_LOADER;
       else if (0 == ::strcasecmp(arg, "language"))
         flag_bits |= LIBLLDB_LOG_LANGUAGE;
       else if (0 == ::strncasecmp(arg, "formatters", 10))
         flag_bits |= LIBLLDB_LOG_DATAFORMATTERS;

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

operator[](size_t idx) {
   return m_ivars[idx];
 }
 
 void ClassDescriptorV2::iVarsStorage::fill(AppleObjCRuntimeV2 &runtime,
                                            ClassDescriptorV2 &descriptor) {
   if (m_filled)
     return;
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES | LIBLLDB_LOG_VERBOSE));
-  if (log)
-    log->Printf("[ClassDescriptorV2::iVarsStorage::fill] class_name = %s",
-                descriptor.GetClassName().AsCString("<unknown"));
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
+  LLDB_LOGV(log, "class_name = {0}", descriptor.GetClassName());
   m_filled = true;
   ObjCLanguageRuntime::EncodingToTypeSP encoding_to_type_sp(
       runtime.GetEncodingToType());
   Process *process(runtime.GetProcess());
   if (!encoding_to_type_sp)
     return;
   descriptor.Describe(nullptr, nullptr, nullptr, [this, process,
                                                   encoding_to_type_sp,
                                                   log](const char *name,
                                                        const char *type,
                                                        lldb::addr_t offset_ptr,
                                                        uint64_t size) -> bool {
     const bool for_expression = false;
     const bool stop_loop = false;
-    if (log)
-      log->Printf("[ClassDescriptorV2::iVarsStorage::fill] name = %s, encoding "
-                  "= %s, offset_ptr = %" PRIx64 ", size = %" PRIu64,
-                  name, type, offset_ptr, size);
+    LLDB_LOGV(log, "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = {3}",
     CompilerType ivar_type =
         encoding_to_type_sp->RealizeType(type, for_expression);
     if (ivar_type) {
-      if (log)
-        log->Printf("[ClassDescriptorV2::iVarsStorage::fill] name = %s, "
-                    "encoding = %s, offset_ptr = %" PRIx64 ", size = %" PRIu64
-                    " , type_size = %" PRIu64,
-                    name, type, offset_ptr, size,
-                    ivar_type.GetByteSize(nullptr));
+      LLDB_LOGV(log,
+                "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = "
+                "{3}, type_size = {4}",
+                name, type, offset_ptr, size, ivar_type.GetByteSize(nullptr));
       Scalar offset_scalar;
       Error error;
       const int offset_ptr_size = 4;
       const bool is_signed = false;
       size_t read = process->ReadScalarIntegerFromMemory(
           offset_ptr, offset_ptr_size, is_signed, offset_scalar, error);
       if (error.Success() && 4 == read) {
-        if (log)
-          log->Printf(
-              "[ClassDescriptorV2::iVarsStorage::fill] offset_ptr = %" PRIx64
-              " --> %" PRIu32,
-              offset_ptr, offset_scalar.SInt());
+        LLDB_LOGV(log, "offset_ptr = {0:x} --> {1}", offset_ptr,
+                  offset_scalar.SInt());
         m_ivars.push_back(
             {ConstString(name), ivar_type, size, offset_scalar.SInt()});
-      } else if (log)
-        log->Printf(
-            "[ClassDescriptorV2::iVarsStorage::fill] offset_ptr = %" PRIx64
-            " --> read fail, read = %zu",
+      } else
+        LLDB_LOGV(log, "offset_ptr = {0:x} --> read fail, read = %{1}",
                   offset_ptr, read);
     }
     return stop_loop;
   });
 }
 
 void ClassDescriptorV2::GetIVarInformation() {
   m_ivars_storage.fill(m_runtime, *this);
 }

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.cpp

const char *PlatformRemoteAppleTV::GetDeviceSupportDirectoryForOSVersion() {
   if (m_device_support_directory_for_os_version[0])
     return m_device_support_directory_for_os_version.c_str();
   return nullptr;
 }
 
 uint32_t
 PlatformRemoteAppleTV::FindFileInAllSDKs(const char *platform_file_path,
                                          FileSpecList &file_list) {
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   if (platform_file_path && platform_file_path[0] &&
       UpdateSDKDirectoryInfosIfNeeded()) {
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
     lldb_private::FileSpec local_file;
     // First try for an exact match of major, minor and update
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx, local_file)) {
         file_list.Append(local_file);
       }
     }
   }
   return file_list.GetSize();
 }
 
Error PlatformRemoteAppleTV::GetSharedModule(
     const ModuleSpec &module_spec, lldb_private::Process *process,
     ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
     ModuleSP *old_module_sp_ptr, bool *did_create_ptr) {
   // For Apple TV, the SDK files are all cached locally on the host
   // system. So first we ask for the file in the cached SDK,
   // then we attempt to get a shared module for the right architecture
   // with the right UUID.
   const FileSpec &platform_file = module_spec.GetFileSpec();
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   Error error;
   char platform_file_path[PATH_MAX];
 
   if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     ModuleSpec platform_module_spec(module_spec);
 
     UpdateSDKDirectoryInfosIfNeeded();
 
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
 
     // If we are connected we migth be able to correctly deduce the SDK
     // directory
     // using the OS build.
     const uint32_t connected_sdk_idx = GetConnectedSDKIndex();
     if (connected_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[connected_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[connected_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, connected_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           m_last_module_sdk_idx = connected_sdk_idx;
           error.Clear();
           return error;
         }
       }
     }
 
     // Try the last SDK index if it is set as most files from an SDK
     // will tend to be valid in that same SDK.
     if (m_last_module_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[m_last_module_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
+                m_sdk_directory_infos[m_last_module_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, m_last_module_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           error.Clear();
           return error;
         }
       }
     }
 
     // First try for an exact match of major, minor and update
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
       if (m_last_module_sdk_idx == sdk_idx) {
         // Skip the last module SDK index if we already searched
         // it above
         continue;
       }
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         // printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
 
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           // Remember the index of the last SDK that we found a file
           // in in case the wrong SDK was selected.

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.cpp

const char *PlatformRemoteAppleWatch::GetDeviceSupportDirectoryForOSVersion() {
   if (m_device_support_directory_for_os_version[0])
     return m_device_support_directory_for_os_version.c_str();
   return nullptr;
 }
 
 uint32_t
 PlatformRemoteAppleWatch::FindFileInAllSDKs(const char *platform_file_path,
                                             FileSpecList &file_list) {
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   if (platform_file_path && platform_file_path[0] &&
       UpdateSDKDirectoryInfosIfNeeded()) {
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
     lldb_private::FileSpec local_file;
     // First try for an exact match of major, minor and update
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx, local_file)) {
         file_list.Append(local_file);
       }
     }
   }
   return file_list.GetSize();
 }
 
Error PlatformRemoteAppleWatch::GetSharedModule(
     const ModuleSpec &module_spec, lldb_private::Process *process,
     ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
     ModuleSP *old_module_sp_ptr, bool *did_create_ptr) {
   // For Apple Watch, the SDK files are all cached locally on the host
   // system. So first we ask for the file in the cached SDK,
   // then we attempt to get a shared module for the right architecture
   // with the right UUID.
   const FileSpec &platform_file = module_spec.GetFileSpec();
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   Error error;
   char platform_file_path[PATH_MAX];
 
   if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     ModuleSpec platform_module_spec(module_spec);
 
     UpdateSDKDirectoryInfosIfNeeded();
 
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
 
     // If we are connected we migth be able to correctly deduce the SDK
     // directory
     // using the OS build.
     const uint32_t connected_sdk_idx = GetConnectedSDKIndex();
     if (connected_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[connected_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[connected_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, connected_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           m_last_module_sdk_idx = connected_sdk_idx;
           error.Clear();
           return error;
         }
       }
     }
 
     // Try the last SDK index if it is set as most files from an SDK
     // will tend to be valid in that same SDK.
     if (m_last_module_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[m_last_module_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[m_last_module_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, m_last_module_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           error.Clear();
           return error;
         }
       }
     }
 
     // First try for an exact match of major, minor and update
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
       if (m_last_module_sdk_idx == sdk_idx) {
         // Skip the last module SDK index if we already searched
         // it above
         continue;
       }
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         // printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
 
         error = ResolveExecutable(platform_module_spec, module_sp, nullptr);
         if (module_sp) {
           // Remember the index of the last SDK that we found a file
           // in in case the wrong SDK was selected.

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.cpp

const char *PlatformRemoteiOS::GetDeviceSupportDirectoryForOSVersion() {
   assert(m_device_support_directory_for_os_version.empty() == false);
   if (m_device_support_directory_for_os_version[0])
     return m_device_support_directory_for_os_version.c_str();
   return NULL;
 }
 
 uint32_t PlatformRemoteiOS::FindFileInAllSDKs(const char *platform_file_path,
                                               FileSpecList &file_list) {
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
   if (platform_file_path && platform_file_path[0] &&
       UpdateSDKDirectoryInfosIfNeeded()) {
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
     lldb_private::FileSpec local_file;
     // First try for an exact match of major, minor and update
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file_path,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx, local_file)) {
         file_list.Append(local_file);
       }
     }
   }
   return file_list.GetSize();
 }
 
Error PlatformRemoteiOS::GetSharedModule(
     const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
     const FileSpecList *module_search_paths_ptr, ModuleSP *old_module_sp_ptr,
     bool *did_create_ptr) {
   // For iOS, the SDK files are all cached locally on the host
   // system. So first we ask for the file in the cached SDK,
   // then we attempt to get a shared module for the right architecture
   // with the right UUID.
   const FileSpec &platform_file = module_spec.GetFileSpec();
-  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
+  Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
   Error error;
   char platform_file_path[PATH_MAX];
 
   if (platform_file.GetPath(platform_file_path, sizeof(platform_file_path))) {
     ModuleSpec platform_module_spec(module_spec);
 
     UpdateSDKDirectoryInfosIfNeeded();
 
     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
 
     // If we are connected we migth be able to correctly deduce the SDK
     // directory
     // using the OS build.
     const uint32_t connected_sdk_idx = GetConnectedSDKIndex();
     if (connected_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[connected_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[connected_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, connected_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, NULL);
         if (module_sp) {
           m_last_module_sdk_idx = connected_sdk_idx;
           error.Clear();
           return error;
         }
       }
     }
 
     // Try the last SDK index if it is set as most files from an SDK
     // will tend to be valid in that same SDK.
     if (m_last_module_sdk_idx < num_sdk_infos) {
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[m_last_module_sdk_idx]
-                        .directory.GetPath()
-                        .c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[m_last_module_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, m_last_module_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, NULL);
         if (module_sp) {
           error.Clear();
           return error;
         }
       }
     }
 
     // First try for an exact match of major, minor and update:
     // If a particalar SDK version was specified via --version or --build, look
     // for a match on disk.
     const SDKDirectoryInfo *current_sdk_info =
         GetSDKDirectoryForCurrentOSVersion();
     const uint32_t current_sdk_idx =
         GetSDKIndexBySDKDirectoryInfo(current_sdk_info);
     if (current_sdk_idx < num_sdk_infos &&
         current_sdk_idx != m_last_module_sdk_idx) {
-      if (log) {
-        log->Printf(
-            "Searching for %s in sdk path %s", platform_file_path,
-            m_sdk_directory_infos[current_sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[current_sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, current_sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         module_sp.reset();
         error = ResolveExecutable(platform_module_spec, module_sp, NULL);
         if (module_sp) {
           m_last_module_sdk_idx = current_sdk_idx;
           error.Clear();
           return error;
         }
       }
     }
 
     // Second try all SDKs that were found.
     for (uint32_t sdk_idx = 0; sdk_idx < num_sdk_infos; ++sdk_idx) {
       if (m_last_module_sdk_idx == sdk_idx) {
         // Skip the last module SDK index if we already searched
         // it above
         continue;
       }
-      if (log) {
-        log->Printf("Searching for %s in sdk path %s", platform_file_path,
-                    m_sdk_directory_infos[sdk_idx].directory.GetPath().c_str());
-      }
+      LLDB_LOGV(log, "Searching for {0} in sdk path {1}", platform_file,
+                m_sdk_directory_infos[sdk_idx].directory);
       if (GetFileInSDK(platform_file_path, sdk_idx,
                        platform_module_spec.GetFileSpec())) {
         // printf ("sdk[%u]: '%s'\n", sdk_idx, local_file.GetPath().c_str());
 
         error = ResolveExecutable(platform_module_spec, module_sp, NULL);
         if (module_sp) {
           // Remember the index of the last SDK that we found a file
           // in in case the wrong SDK was selected.
while (true) {
       if (part.IsEmpty() || part == unix_root_dir)
         break;
       path_parts.push_back(part.AsCString());
     }
     const size_t path_parts_size = path_parts.size();
 
     size_t num_module_search_paths = module_search_paths_ptr->GetSize();
     for (size_t i = 0; i < num_module_search_paths; ++i) {
-      Log *log_verbose = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST |
-                                                    LIBLLDB_LOG_VERBOSE);
-      if (log_verbose)
-          log_verbose->Printf ("PlatformRemoteiOS::GetSharedModule searching for binary in search-path %s", module_search_paths_ptr->GetFileSpecAtIndex(i).GetPath().c_str());
+      LLDB_LOGV(log, "searching for binary in search-path {0}",
+                module_search_paths_ptr->GetFileSpecAtIndex(i));
       // Create a new FileSpec with this module_search_paths_ptr
       // plus just the filename ("UIFoundation"), then the parent
       // dir plus filename ("UIFoundation.framework/UIFoundation")
       // etc - up to four names (to handle "Foo.framework/Contents/MacOS/Foo")
 
       for (size_t j = 0; j < 4 && j < path_parts_size - 1; ++j) {
         FileSpec path_to_try(module_search_paths_ptr->GetFileSpecAtIndex(i));
 

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 #else
     InitializeThreadsPrivate();
     Py_InitializeEx(0);
 #endif
   }
 
   ~InitializePythonRAII() {
     if (m_was_already_initialized) {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
-                                                      LIBLLDB_LOG_VERBOSE));
-
-      if (log) {
-        log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
-                    m_was_already_initialized == PyGILState_UNLOCKED ? "un"
-                                                                     : "");
-      }
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+      LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
+                m_was_already_initialized == PyGILState_UNLOCKED ? "un" : "");
       PyGILState_Release(m_gil_state);
     } else {
       // We initialized the threads in this function, just unlock the GIL.
       PyEval_SaveThread();
     }
 
     m_stdin_tty_state.Restore();
   }
 
 private:
   void InitializePythonHome() {
 #if defined(LLDB_PYTHON_HOME)
 #if PY_MAJOR_VERSION >= 3
     size_t size = 0;
     static wchar_t *g_python_home = Py_DecodeLocale(LLDB_PYTHON_HOME, &size);
 #else
     static char g_python_home[] = LLDB_PYTHON_HOME;
 #endif
     Py_SetPythonHome(g_python_home);
 #endif
   }
 
   void InitializeThreadsPrivate() {
     if (PyEval_ThreadsInitialized()) {
-      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
-                                                      LIBLLDB_LOG_VERBOSE));
+      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
 
       m_was_already_initialized = true;
       m_gil_state = PyGILState_Ensure();
-      if (log) {
-        log->Printf("Ensured PyGILState. Previous state = %slocked\n",
-                    m_gil_state == PyGILState_UNLOCKED ? "un" : "");
-      }
+      LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked\n",
       return;
     }
 
     // InitThreads acquires the GIL if it hasn't been called before.
     PyEval_InitThreads();
   }
 
   TerminalState m_stdin_tty_state;
if ((on_entry & InitSession) == InitSession) {
     if (DoInitSession(on_entry, in, out, err) == false) {
       // Don't teardown the session if we didn't init it.
       m_teardown_session = false;
     }
   }
 }
 
 bool ScriptInterpreterPython::Locker::DoAcquireLock() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
-                                                  LIBLLDB_LOG_VERBOSE));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
   m_GILState = PyGILState_Ensure();
-  if (log)
-    log->Printf("Ensured PyGILState. Previous state = %slocked\n",
-                m_GILState == PyGILState_UNLOCKED ? "un" : "");
+  LLDB_LOGV(log, "Ensured PyGILState. Previous state = {0}locked",
 
   // we need to save the thread state when we first start the command
   // because we might decide to interrupt it while some action is taking
   // place outside of Python (e.g. printing to screen, waiting for the network,
   // ...)
   // in that case, _PyThreadState_Current will be NULL - and we would be unable
   // to set the asynchronous exception - not a desirable situation
   m_python_interpreter->SetThreadState(PyThreadState_Get());
   m_python_interpreter->IncrementLockCount();
   return true;
 }
 
 bool ScriptInterpreterPython::Locker::DoInitSession(uint16_t on_entry_flags,
                                                     FILE *in, FILE *out,
                                                     FILE *err) {
   if (!m_python_interpreter)
     return false;
   return m_python_interpreter->EnterSession(on_entry_flags, in, out, err);
 }
 
 bool ScriptInterpreterPython::Locker::DoFreeLock() {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT |
-                                                  LIBLLDB_LOG_VERBOSE));
-  if (log)
-    log->Printf("Releasing PyGILState. Returning to state = %slocked\n",
-                m_GILState == PyGILState_UNLOCKED ? "un" : "");
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SCRIPT));
+  LLDB_LOGV(log, "Releasing PyGILState. Returning to state = {0}locked",
   PyGILState_Release(m_GILState);
   m_python_interpreter->DecrementLockCount();
   return true;
 }
 
 bool ScriptInterpreterPython::Locker::DoTearDownSession() {
   if (!m_python_interpreter)
     return false;

lldb/trunk/source/Target/Memory.cpp

 {
   assert(byte_size > chunk_size);
 }
 
 AllocatedBlock::~AllocatedBlock() {}
 
 lldb::addr_t AllocatedBlock::ReserveBlock(uint32_t size) {
   addr_t addr = LLDB_INVALID_ADDRESS;
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
   if (size <= m_byte_size) {
     const uint32_t needed_chunks = CalculateChunksNeededForSize(size);
 
     if (m_offset_to_chunk_size.empty()) {
       m_offset_to_chunk_size[0] = needed_chunks;
-      if (log)
-        log->Printf("[1] AllocatedBlock::ReserveBlock(%p) (size = %u (0x%x)) "
-                    "=> offset = 0x%x, %u %u bit chunks",
-                    (void *)this, size, size, 0, needed_chunks, m_chunk_size);
+      LLDB_LOGV(log,
+                "[1] ({0}) (size = {1} ({1:x})) => offset = {2:x}, {3} "
+                "{4} bit chunks",
+                this, size, 0, needed_chunks, m_chunk_size);
       addr = m_addr;
     } else {
       uint32_t last_offset = 0;
       OffsetToChunkSize::const_iterator pos = m_offset_to_chunk_size.begin();
       OffsetToChunkSize::const_iterator end = m_offset_to_chunk_size.end();
       while (pos != end) {
         if (pos->first > last_offset) {
           const uint32_t bytes_available = pos->first - last_offset;
           const uint32_t num_chunks =
               CalculateChunksNeededForSize(bytes_available);
           if (num_chunks >= needed_chunks) {
             m_offset_to_chunk_size[last_offset] = needed_chunks;
-            if (log)
-              log->Printf("[2] AllocatedBlock::ReserveBlock(%p) (size = %u "
-                          "(0x%x)) => offset = 0x%x, %u %u bit chunks - "
-                          "num_chunks %zu",
-                          (void *)this, size, size, last_offset, needed_chunks,
-                          m_chunk_size, m_offset_to_chunk_size.size());
+            LLDB_LOGV(log,
+                      "[2] ({0}) (size = {1} ({1:x})) => offset = {2:x}, "
+                      "{3} {4} bit chunks- num_chunks {5}",
+                      this, size, last_offset, needed_chunks, m_chunk_size,
+                      m_offset_to_chunk_size.size());
             addr = m_addr + last_offset;
             break;
           }
         }
 
         last_offset = pos->first + pos->second * m_chunk_size;
 
         if (++pos == end) {
           // Last entry...
           const uint32_t chunks_left =
               CalculateChunksNeededForSize(m_byte_size - last_offset);
           if (chunks_left >= needed_chunks) {
             m_offset_to_chunk_size[last_offset] = needed_chunks;
-            if (log)
-              log->Printf("[3] AllocatedBlock::ReserveBlock(%p) (size = %u "
-                          "(0x%x)) => offset = 0x%x, %u %u bit chunks - "
-                          "num_chunks %zu",
-                          (void *)this, size, size, last_offset, needed_chunks,
-                          m_chunk_size, m_offset_to_chunk_size.size());
+            LLDB_LOGV(log,
+                      "[3] ({0}) (size = {1} ({1:x})) => offset = {2:x}, "
+                      "{3} {4} bit chunks- num_chunks {5}",
+                      this, size, last_offset, needed_chunks, m_chunk_size,
+                      m_offset_to_chunk_size.size());
             addr = m_addr + last_offset;
             break;
           }
         }
       }
     }
     //        const uint32_t total_chunks = m_allocated.size ();
     //        uint32_t unallocated_idx = 0;
if (size <= m_byte_size) {
     //        {
     //            const uint32_t end_bit_idx = unallocated_idx + needed_chunks;
     //            for (uint32_t idx = first_chunk_idx; idx < end_bit_idx; ++idx)
     //                m_allocated.set(idx);
     //            return m_addr + m_chunk_size * first_chunk_idx;
     //        }
   }
 
-  if (log)
-    log->Printf("AllocatedBlock::ReserveBlock(%p) (size = %u (0x%x)) => "
-                "0x%16.16" PRIx64,
-                (void *)this, size, size, (uint64_t)addr);
+  LLDB_LOGV(log, "({0}) (size = {1} ({1:x})) => {2:x}", this, size, addr);
   return addr;
 }
 
 bool AllocatedBlock::FreeBlock(addr_t addr) {
   uint32_t offset = addr - m_addr;
   OffsetToChunkSize::iterator pos = m_offset_to_chunk_size.find(offset);
   bool success = false;
   if (pos != m_offset_to_chunk_size.end()) {
     m_offset_to_chunk_size.erase(pos);
     success = true;
   }
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
-  if (log)
-    log->Printf("AllocatedBlock::FreeBlock(%p) (addr = 0x%16.16" PRIx64
-                ") => %i, num_chunks: %zu",
-                (void *)this, (uint64_t)addr, success,
-                m_offset_to_chunk_size.size());
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+  LLDB_LOGV(log, "({0}) (addr = {1:x}) => {2}, num_chunks: {3}", this, addr,
+            success, m_offset_to_chunk_size.size());
   return success;
 }
 
 AllocatedMemoryCache::AllocatedMemoryCache(Process &process)
     : m_process(process), m_mutex(), m_memory_map() {}
 
 AllocatedMemoryCache::~AllocatedMemoryCache() {}
 

lldb/trunk/source/Target/SectionLoadList.cpp

if (pos != m_sect_to_addr.end())
       section_load_addr = pos->second;
   }
   return section_load_addr;
 }
 
 bool SectionLoadList::SetSectionLoadAddress(const lldb::SectionSP &section,
                                             addr_t load_addr,
                                             bool warn_multiple) {
-  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER |
-                                                  LIBLLDB_LOG_VERBOSE));
-
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
   ModuleSP module_sp(section->GetModule());
 
   if (module_sp) {
-    if (log) {
-      const FileSpec &module_file_spec(module_sp->GetFileSpec());
-      log->Printf("SectionLoadList::%s (section = %p (%s.%s), load_addr = "
-                  "0x%16.16" PRIx64 ") module = %p",
-                  __FUNCTION__, static_cast<void *>(section.get()),
-                  module_file_spec.GetPath().c_str(),
-                  section->GetName().AsCString(), load_addr,
-                  static_cast<void *>(module_sp.get()));
-    }
+    LLDB_LOGV(log, "(section = {0} ({1}.{2}), load_addr = {3:x}) module = {4}",
+              section.get(), module_sp->GetFileSpec(), section->GetName(),
+              load_addr, module_sp.get());
 
     if (section->GetByteSize() == 0)
       return false; // No change
 
     // Fill in the section -> load_addr map
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     sect_to_addr_collection::iterator sta_pos =
         m_sect_to_addr.find(section.get());
bool SectionLoadList::SetSectionLoadAddress(const lldb::SectionSP &section,
   }
   return false;
 }
 
 size_t SectionLoadList::SetSectionUnloaded(const lldb::SectionSP &section_sp) {
   size_t unload_count = 0;
 
   if (section_sp) {
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER |
-                                                    LIBLLDB_LOG_VERBOSE));
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-    if (log) {
+    if (log && log->GetVerbose()) {
       ModuleSP module_sp = section_sp->GetModule();
       std::string module_name("<Unknown>");
       if (module_sp) {
         const FileSpec &module_file_spec(
             section_sp->GetModule()->GetFileSpec());
         module_name = module_file_spec.GetPath();
       }
       log->Printf("SectionLoadList::%s (section = %p (%s.%s))", __FUNCTION__,
if (sta_pos != m_sect_to_addr.end()) {
         m_addr_to_sect.erase(ats_pos);
     }
   }
   return unload_count;
 }
 
 bool SectionLoadList::SetSectionUnloaded(const lldb::SectionSP &section_sp,
                                          addr_t load_addr) {
-  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER |
-                                                  LIBLLDB_LOG_VERBOSE));
+  Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
 
-  if (log) {
+  if (log && log->GetVerbose()) {
     ModuleSP module_sp = section_sp->GetModule();
     std::string module_name("<Unknown>");
     if (module_sp) {
       const FileSpec &module_file_spec(section_sp->GetModule()->GetFileSpec());
       module_name = module_file_spec.GetPath();
     }
     log->Printf(
         "SectionLoadList::%s (section = %p (%s.%s), load_addr = 0x%16.16" PRIx64

lldb/trunk/source/Target/ThreadPlanCallFunction.cpp

: ThreadPlan(ThreadPlan::eKindCallFunction, "Call function plan", thread,
       m_should_clear_cxx_exception_bp(false),
       m_stop_address(LLDB_INVALID_ADDRESS), m_return_type(CompilerType()) {}
 
 ThreadPlanCallFunction::~ThreadPlanCallFunction() {
   DoTakedown(PlanSucceeded());
 }
 
 void ThreadPlanCallFunction::ReportRegisterState(const char *message) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP |
-                                                  LIBLLDB_LOG_VERBOSE));
-  if (log) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
+  if (log && log->GetVerbose()) {
     StreamString strm;
     RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
 
     log->PutCString(message);
 
     RegisterValue reg_value;
 
     for (uint32_t reg_idx = 0, num_registers = reg_ctx->GetRegisterCount();

lldb/trunk/source/Utility/ConstString.cpp

void ConstString::SetTrimmedCStringWithLength(const char *cstr,
                                               size_t cstr_len) {
   m_string = StringPool().GetConstTrimmedCStringWithLength(cstr, cstr_len);
 }
 
 size_t ConstString::StaticMemorySize() {
   // Get the size of the static string pool
   return StringPool().MemorySize();
 }
+
+void llvm::format_provider<ConstString>::format(const ConstString &CS,
+                                                llvm::raw_ostream &OS,
+                                                llvm::StringRef Options) {
+  format_provider<StringRef>::format(CS.AsCString(), OS, Options);
+}

lldb/trunk/unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
+  ConstStringTest.cpp
   ModuleCacheTest.cpp
   StringExtractorTest.cpp
   TaskPoolTest.cpp
   TimeoutTest.cpp
   UriParserTest.cpp
 
   LINK_LIBS
       lldbCore

lldb/trunk/unittests/Utility/ConstStringTest.cpp

+//===-- ConstStringTest.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/ConstString.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+
+TEST(ConstStringTest, format_provider) {
+  EXPECT_EQ("foo", llvm::formatv("{0}", ConstString("foo")).str());
+}