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}");
}
}
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(
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;
}
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;
}
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);
}
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;
}
"<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;
});
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;
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();
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;
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();
}
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);
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;
}
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;
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;
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)
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);
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;
}
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;
}
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;
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;
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();
}
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();
}
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;
}
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;
}
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;
}
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;
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;
}
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 {
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();
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;
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;
auto type_system_or_err =
GetScratchTypeSystemForLanguage(language, create_on_demand);
if (!type_system_or_err)
- LLDB_LOG_ERROR(GetLog(LLDBLog::Target), type_system_or_err.takeError(),
- "Language '{}' has expression support but no scratch type "
- "system available",
- Language::GetNameForLanguageType(language));
+ LLDB_LOG_ERROR(
+ GetLog(LLDBLog::Target), type_system_or_err.takeError(),
+ "Language '{1}' has expression support but no scratch type "
+ "system available: {0}",
+ Language::GetNameForLanguageType(language));
else
if (auto ts = *type_system_or_err)
scratch_type_systems.push_back(ts);
auto type_system_or_err = GetScratchTypeSystemForLanguage(language, true);
if (auto err = type_system_or_err.takeError()) {
- LLDB_LOG_ERROR(GetLog(LLDBLog::Target), std::move(err),
- "Unable to get persistent expression state for language {}",
- Language::GetNameForLanguageType(language));
+ LLDB_LOG_ERROR(
+ GetLog(LLDBLog::Target), std::move(err),
+ "Unable to get persistent expression state for language {1}: {0}",
+ Language::GetNameForLanguageType(language));
return nullptr;
}
return ts->GetPersistentExpressionState();
LLDB_LOG(GetLog(LLDBLog::Target),
- "Unable to get persistent expression state for language {}",
+ "Unable to get persistent expression state for language {1}: {0}",
Language::GetNameForLanguageType(language));
return nullptr;
}
auto ts = *type_system_or_err;
if (!ts)
LLDB_LOG_ERROR(GetLog(LLDBLog::Target), std::move(err),
- "Scratch type system is no longer live");
+ "Scratch type system is no longer live: {0}");
else
persistent_var_sp =
ts->GetPersistentExpressionState()->GetVariable(expr);
Thread &ThreadPlanTracer::GetThread() {
if (m_thread)
return *m_thread;
-
+
ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(m_tid);
m_thread = thread_sp.get();
return *m_thread;
auto type_system_or_err =
target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
if (auto err = type_system_or_err.takeError()) {
- LLDB_LOG_ERROR(GetLog(LLDBLog::Types), std::move(err),
- "Unable to get integer pointer type from TypeSystem");
+ LLDB_LOG_ERROR(
+ GetLog(LLDBLog::Types), std::move(err),
+ "Unable to get integer pointer type from TypeSystem: {0}");
} else {
if (auto ts = *type_system_or_err)
m_intptr_type = TypeFromUser(ts->GetBuiltinTypeForEncodingAndBitSize(