Merge pull request #7052 from apple/🍒/5.9/e0e36e3725b5+520681e56d3a

JDevlieghere · web-flow · commit 781ba90e25b0 · 2023-07-06T13:02:33.000-07:00
🍒/5.9/e0e36e3725b5+520681e56d3a
diff --git a/lldb/source/API/SBTarget.cpp b/lldb/source/API/SBTarget.cpp
@@ -1153,8 +1153,8 @@ bool SBTarget::FindBreakpointsByName(const char *name,
     llvm::Expected<std::vector<BreakpointSP>> expected_vector =
         target_sp->GetBreakpointList().FindBreakpointsByName(name);
     if (!expected_vector) {
-      LLDB_LOG(GetLog(LLDBLog::Breakpoints), "invalid breakpoint name: {}",
-               llvm::toString(expected_vector.takeError()));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Breakpoints), expected_vector.takeError(),
+                     "invalid breakpoint name: {0}");
       return false;
     }
     for (BreakpointSP bkpt_sp : *expected_vector) {
@@ -1627,7 +1627,7 @@ const char *SBTarget::GetTriple() {
 
 const char *SBTarget::GetABIName() {
   LLDB_INSTRUMENT_VA(this);
-  
+
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::string abi_name(target_sp->GetABIName().str());
diff --git a/lldb/source/Breakpoint/Watchpoint.cpp b/lldb/source/Breakpoint/Watchpoint.cpp
@@ -41,14 +41,14 @@ Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
         target.GetScratchTypeSystemForLanguage(eLanguageTypeC);
     if (auto err = type_system_or_err.takeError()) {
       LLDB_LOG_ERROR(GetLog(LLDBLog::Watchpoints), std::move(err),
-                     "Failed to set type.");
+                     "Failed to set type: {0}");
     } else {
       if (auto ts = *type_system_or_err)
         m_type =
             ts->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size);
       else
         LLDB_LOG_ERROR(GetLog(LLDBLog::Watchpoints), std::move(err),
-                       "Failed to set type. Typesystem is no longer live.");
+                       "Failed to set type: Typesystem is no longer live: {0}");
     }
   }
 
diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp
@@ -1880,8 +1880,8 @@ bool Debugger::StartEventHandlerThread() {
     if (event_handler_thread) {
       m_event_handler_thread = *event_handler_thread;
     } else {
-      LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
-               llvm::toString(event_handler_thread.takeError()));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Host), event_handler_thread.takeError(),
+                     "failed to launch host thread: {0}");
     }
 
     // Make sure DefaultEventHandler() is running and listening to events
@@ -2021,8 +2021,8 @@ bool Debugger::StartIOHandlerThread() {
     if (io_handler_thread) {
       m_io_handler_thread = *io_handler_thread;
     } else {
-      LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
-               llvm::toString(io_handler_thread.takeError()));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Host), io_handler_thread.takeError(),
+                     "failed to launch host thread: {0}");
     }
   }
   return m_io_handler_thread.IsJoinable();
diff --git a/lldb/source/Core/ThreadedCommunication.cpp b/lldb/source/Core/ThreadedCommunication.cpp
@@ -178,8 +178,8 @@ bool ThreadedCommunication::StartReadThread(Status *error_ptr) {
     if (error_ptr)
       *error_ptr = Status(maybe_thread.takeError());
     else {
-      LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
-               llvm::toString(maybe_thread.takeError()));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Host), maybe_thread.takeError(),
+                     "failed to launch host thread: {0}");
     }
   }
 
diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp
@@ -204,7 +204,7 @@ CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
             exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
         if (auto err = type_system_or_err.takeError()) {
           LLDB_LOG_ERROR(GetLog(LLDBLog::Types), std::move(err),
-                         "Unable to get CompilerType from TypeSystem");
+                         "Unable to get CompilerType from TypeSystem: {0}");
         } else {
           if (auto ts = *type_system_or_err)
             m_compiler_type = ts->GetBuiltinTypeForEncodingAndBitSize(
diff --git a/lldb/source/Host/common/ProcessLaunchInfo.cpp b/lldb/source/Host/common/ProcessLaunchInfo.cpp
@@ -182,8 +182,8 @@ bool ProcessLaunchInfo::MonitorProcess() const {
     llvm::Expected<HostThread> maybe_thread =
         Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID());
     if (!maybe_thread)
-      LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
-               llvm::toString(maybe_thread.takeError()));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Host), maybe_thread.takeError(),
+                     "failed to launch host thread: {0}");
     return true;
   }
   return false;
diff --git a/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp b/lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp
@@ -45,7 +45,7 @@ class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
         lldb::eLanguageTypeC_plus_plus);
     if (auto err = type_system_or_err.takeError()) {
       LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), std::move(err),
-                     "Failed to get scratch TypeSystemClang");
+                     "Failed to get scratch TypeSystemClang: {0}");
       return;
     }
 
diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp
@@ -1698,7 +1698,7 @@ AppleObjCRuntimeV2::SharedCacheImageHeaders::CreateSharedCacheImageHeaders(
                                   entsize));
   if (auto Err = shared_cache_image_headers->UpdateIfNeeded()) {
     LLDB_LOG_ERROR(log, std::move(Err),
-                   "Failed to update SharedCacheImageHeaders");
+                   "Failed to update SharedCacheImageHeaders: {0}");
     return nullptr;
   }
 
@@ -1758,7 +1758,7 @@ bool AppleObjCRuntimeV2::SharedCacheImageHeaders::IsImageLoaded(
   if (auto Err = UpdateIfNeeded()) {
     Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);
     LLDB_LOG_ERROR(log, std::move(Err),
-                   "Failed to update SharedCacheImageHeaders");
+                   "Failed to update SharedCacheImageHeaders: {0}");
   }
   return m_loaded_images.test(image_index);
 }
@@ -1767,7 +1767,7 @@ uint64_t AppleObjCRuntimeV2::SharedCacheImageHeaders::GetVersion() {
   if (auto Err = UpdateIfNeeded()) {
     Log *log = GetLog(LLDBLog::Process | LLDBLog::Types);
     LLDB_LOG_ERROR(log, std::move(Err),
-                   "Failed to update SharedCacheImageHeaders");
+                   "Failed to update SharedCacheImageHeaders: {0}");
   }
   return m_version;
 }
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp
@@ -1886,7 +1886,7 @@ void SwiftLanguageRuntimeImpl::WillStartExecutingUserExpression(
   if (!type_system_or_err) {
     LLDB_LOG_ERROR(
         log, type_system_or_err.takeError(),
-        "SwiftLanguageRuntime: Unable to get pointer to type system");
+        "SwiftLanguageRuntime: Unable to get pointer to type system: {0}");
     return;
   }
 
@@ -1961,7 +1961,7 @@ void SwiftLanguageRuntimeImpl::DidFinishExecutingUserExpression(
   if (!type_system_or_err) {
     LLDB_LOG_ERROR(
         log, type_system_or_err.takeError(),
-        "SwiftLanguageRuntime: Unable to get pointer to type system");
+        "SwiftLanguageRuntime: Unable to get pointer to type system: {0}");
     return;
   }
 
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
@@ -730,7 +730,7 @@ bool ProcessKDP::StartAsyncThread() {
       "<lldb.process.kdp-remote.async>", [this] { return AsyncThread(); });
   if (!async_thread) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),
-                   "failed to launch host thread: {}");
+                   "failed to launch host thread: {0}");
     return false;
   }
   m_async_thread = *async_thread;
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -3411,7 +3411,7 @@ bool ProcessGDBRemote::StartAsyncThread() {
         });
     if (!async_thread) {
       LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),
-                     "failed to launch host thread: {}");
+                     "failed to launch host thread: {0}");
       return false;
     }
     m_async_thread = *async_thread;
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp b/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp
@@ -43,7 +43,7 @@ void DWARFDebugAranges::extract(const DWARFDataExtractor &debug_aranges_data) {
       Log *log = GetLog(DWARFLog::DebugInfo);
       LLDB_LOG_ERROR(log, std::move(error),
                      "DWARFDebugAranges::extract failed to extract "
-                     ".debug_aranges set at offset %#" PRIx64,
+                     ".debug_aranges set at offset {1:x}: {0}",
                      set_offset);
     } else {
       const uint32_t num_descriptors = set.NumDescriptors();
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -828,7 +828,7 @@ Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
   auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to parse function");
+                   "Unable to parse function: {0}");
     return nullptr;
   }
   auto ts = *type_system_or_err;
@@ -876,7 +876,7 @@ SymbolFileDWARF::ConstructFunctionDemangledName(const DWARFDIE &die) {
   auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to construct demangled name for function");
+                   "Unable to construct demangled name for function: {0}");
     return ConstString();
   }
 
@@ -1073,7 +1073,7 @@ SymbolFileDWARF::GetTypeUnitSupportFiles(DWARFTypeUnit &tu) {
       Log *log = GetLog(DWARFLog::DebugInfo);
       LLDB_LOG_ERROR(log, std::move(error),
                      "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
-                     "the line table prologue");
+                     "the line table prologue: {0}");
     };
     ElapsedTime elapsed(m_parse_time);
     llvm::Error error = prologue.parse(data, &line_table_offset, report, ctx);
@@ -2174,7 +2174,7 @@ bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
       decl_ctx_type_system->GetMinimumLanguage(nullptr));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to match namespace decl using TypeSystem");
+                   "Unable to match namespace decl using TypeSystem: {0}");
     return false;
   }
 
@@ -2955,7 +2955,7 @@ TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
         auto type_system_or_err = GetTypeSystemForLanguage(language);
         if (auto err = type_system_or_err.takeError()) {
           LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                         "Cannot get TypeSystem for language {}",
+                         "Cannot get TypeSystem for language {1}: {0}",
                          Language::GetNameForLanguageType(language));
         } else {
           type_system = *type_system_or_err;
@@ -3113,7 +3113,7 @@ TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
   auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to parse type");
+                   "Unable to parse type: {0}");
     return {};
   }
   auto ts = *type_system_or_err;
@@ -4193,7 +4193,7 @@ DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &unit) {
   auto type_system_or_err = GetTypeSystem(unit);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get DWARFASTParser");
+                   "Unable to get DWARFASTParser: {0}");
     return nullptr;
   }
   if (auto ts = *type_system_or_err)
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp b/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
@@ -352,7 +352,7 @@ void SymbolFileNativePDB::InitializeObject() {
       lldb::eLanguageTypeC_plus_plus);
   if (auto err = ts_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Failed to initialize");
+                   "Failed to initialize: {0}");
   } else {
     if (auto ts = *ts_or_err)
       ts->SetSymbolFile(this);
diff --git a/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp b/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
@@ -314,7 +314,7 @@ SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
   auto type_system_or_err = GetTypeSystemForLanguage(lang);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to parse PDBFunc");
+                   "Unable to parse PDBFunc: {0}");
     return nullptr;
   }
 
@@ -565,7 +565,7 @@ lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to ResolveTypeUID");
+                   "Unable to ResolveTypeUID: {0}");
     return nullptr;
   }
 
@@ -602,7 +602,7 @@ bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get dynamic array info for UID");
+                   "Unable to get dynamic array info for UID: {0}");
     return false;
   }
   auto ts = *type_system_or_err;
@@ -624,7 +624,7 @@ lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get decl for UID");
+                   "Unable to get decl for UID: {0}");
     return CompilerDecl();
   }
   auto ts = *type_system_or_err;
@@ -654,7 +654,7 @@ SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get DeclContext for UID");
+                   "Unable to get DeclContext for UID: {0}");
     return CompilerDeclContext();
   }
 
@@ -685,7 +685,7 @@ SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get DeclContext containing UID");
+                   "Unable to get DeclContext containing UID: {0}");
     return CompilerDeclContext();
   }
 
@@ -715,7 +715,7 @@ void SymbolFilePDB::ParseDeclsForContext(
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to parse decls for context");
+                   "Unable to parse decls for context: {0}");
     return;
   }
 
@@ -1464,7 +1464,7 @@ void SymbolFilePDB::DumpClangAST(Stream &s) {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to dump ClangAST");
+                   "Unable to dump ClangAST: {0}");
     return;
   }
 
@@ -1677,7 +1677,7 @@ PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to get PDB AST parser");
+                   "Unable to get PDB AST parser: {0}");
     return nullptr;
   }
 
@@ -1698,7 +1698,7 @@ SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                   "Unable to find namespace {}", name.AsCString());
+                   "Unable to find namespace {1}: {0}", name.AsCString());
     return CompilerDeclContext();
   }
   auto ts = *type_system_or_err;
@@ -1993,7 +1993,7 @@ bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(
         GetLog(LLDBLog::Symbols), std::move(err),
-        "Unable to determine if DeclContext matches this symbol file");
+        "Unable to determine if DeclContext matches this symbol file: {0}");
     return false;
   }
 
diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp
@@ -148,7 +148,7 @@ lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
             eLanguageTypeObjC, exe_ctx);
         if (!utility_fn_or_error) {
           LLDB_LOG_ERROR(log, utility_fn_or_error.takeError(),
-                         "Failed to create utility function: {0}.");
+                         "Failed to create utility function: {0}");
         }
         m_get_item_info_impl_code = std::move(*utility_fn_or_error);
       } else {
@@ -162,13 +162,13 @@ lldb::addr_t AppleGetItemInfoHandler::SetupGetItemInfoFunction(
               eLanguageTypeC);
       if (auto err = type_system_or_err.takeError()) {
         LLDB_LOG_ERROR(log, std::move(err),
-                       "Error inserting get-item-info function");
+                       "Error inserting get-item-info function: {0}");
         return args_addr;
       }
       auto ts = *type_system_or_err;
       if (!ts)
         return args_addr;
-      
+
       CompilerType get_item_info_return_type =
           ts->GetBasicTypeFromAST(eBasicTypeVoid)
               .GetPointerType();
diff --git a/lldb/source/Symbol/Type.cpp b/lldb/source/Symbol/Type.cpp
@@ -537,8 +537,9 @@ bool Type::ResolveCompilerType(ResolveState compiler_type_resolve_state) {
       auto type_system_or_err =
           m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
       if (auto err = type_system_or_err.takeError()) {
-        LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
-                       "Unable to construct void type from TypeSystemClang");
+        LLDB_LOG_ERROR(
+            GetLog(LLDBLog::Symbols), std::move(err),
+            "Unable to construct void type from TypeSystemClang: {0}");
       } else {
         CompilerType void_compiler_type;
         auto ts = *type_system_or_err;
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
@@ -3746,8 +3746,8 @@ bool Process::StartPrivateStateThread(bool is_secondary_thread) {
           },
           8 * 1024 * 1024);
   if (!private_state_thread) {
-    LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
-             llvm::toString(private_state_thread.takeError()));
+    LLDB_LOG_ERROR(GetLog(LLDBLog::Host), private_state_thread.takeError(),
+                   "failed to launch host thread: {0}");
     return false;
   }
 
diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
@@ -1368,7 +1368,7 @@ lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
             target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
         if (auto err = c_type_system_or_err.takeError()) {
           LLDB_LOG_ERROR(GetLog(LLDBLog::Thread), std::move(err),
-                         "Unable to guess value for given address");
+                         "Unable to guess value for given address: {0}");
           return ValueObjectSP();
         } else {
           auto ts = *c_type_system_or_err;
diff --git a/lldb/source/Target/Target.cpp b/lldb/source/Target/Target.cpp
diff --git a/lldb/source/Target/ThreadPlanTracer.cpp b/lldb/source/Target/ThreadPlanTracer.cpp

Original file line number	Diff line number	Diff line change
`@@ -178,8 +178,8 @@ bool ThreadedCommunication::StartReadThread(Status *error_ptr) {`
`178`	`178`	`if (error_ptr)`
`179`	`179`	`*error_ptr = Status(maybe_thread.takeError());`
`180`	`180`	`else {`
`181`		`- LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",`
`182`		`- llvm::toString(maybe_thread.takeError()));`
	`181`	`+ LLDB_LOG_ERROR(GetLog(LLDBLog::Host), maybe_thread.takeError(),`
	`182`	`+ "failed to launch host thread: {0}");`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd {`
`45`	`45`	`lldb::eLanguageTypeC_plus_plus);`
`46`	`46`	`if (auto err = type_system_or_err.takeError()) {`
`47`	`47`	`LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), std::move(err),`
`48`		`- "Failed to get scratch TypeSystemClang");`
	`48`	`+ "Failed to get scratch TypeSystemClang: {0}");`
`49`	`49`	`return;`
`50`	`50`	`}`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -1698,7 +1698,7 @@ AppleObjCRuntimeV2::SharedCacheImageHeaders::CreateSharedCacheImageHeaders(`
`1698`	`1698`	`entsize));`
`1699`	`1699`	`if (auto Err = shared_cache_image_headers->UpdateIfNeeded()) {`
`1700`	`1700`	`LLDB_LOG_ERROR(log, std::move(Err),`
`1701`		`- "Failed to update SharedCacheImageHeaders");`
	`1701`	`+ "Failed to update SharedCacheImageHeaders: {0}");`
`1702`	`1702`	`return nullptr;`
`1703`	`1703`	`}`
`1704`	`1704`
`@@ -1758,7 +1758,7 @@ bool AppleObjCRuntimeV2::SharedCacheImageHeaders::IsImageLoaded(`
`1758`	`1758`	`if (auto Err = UpdateIfNeeded()) {`
`1759`	`1759`	`Log *log = GetLog(LLDBLog::Process \| LLDBLog::Types);`
`1760`	`1760`	`LLDB_LOG_ERROR(log, std::move(Err),`
`1761`		`- "Failed to update SharedCacheImageHeaders");`
	`1761`	`+ "Failed to update SharedCacheImageHeaders: {0}");`
`1762`	`1762`	`}`
`1763`	`1763`	`return m_loaded_images.test(image_index);`
`1764`	`1764`	`}`
`@@ -1767,7 +1767,7 @@ uint64_t AppleObjCRuntimeV2::SharedCacheImageHeaders::GetVersion() {`
`1767`	`1767`	`if (auto Err = UpdateIfNeeded()) {`
`1768`	`1768`	`Log *log = GetLog(LLDBLog::Process \| LLDBLog::Types);`
`1769`	`1769`	`LLDB_LOG_ERROR(log, std::move(Err),`
`1770`		`- "Failed to update SharedCacheImageHeaders");`
	`1770`	`+ "Failed to update SharedCacheImageHeaders: {0}");`
`1771`	`1771`	`}`
`1772`	`1772`	`return m_version;`
`1773`	`1773`	`}`
Original file line number	Diff line number	Diff line change
`@@ -730,7 +730,7 @@ bool ProcessKDP::StartAsyncThread() {`
`730`	`730`	`"<lldb.process.kdp-remote.async>", [this] { return AsyncThread(); });`
`731`	`731`	`if (!async_thread) {`
`732`	`732`	`LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),`
`733`		`- "failed to launch host thread: {}");`
	`733`	`+ "failed to launch host thread: {0}");`
`734`	`734`	`return false;`
`735`	`735`	`}`
`736`	`736`	`m_async_thread = *async_thread;`