Merge pull request #6412 from augusto2112/fix-log

Cherrypick b34767d and fix logging without format

Author: augusto2112

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -270,7 +270,36 @@ class TargetReflectionContext
   const swift::reflection::TypeInfo *
   getTypeInfo(const swift::reflection::TypeRef *type_ref,
               swift::remote::TypeInfoProvider *provider) override {
-    return m_reflection_ctx.getTypeInfo(type_ref, provider);
+    if (!type_ref)
+      return nullptr;
+
+    Log *log(GetLog(LLDBLog::Types));
+    if (log && log->GetVerbose()) {
+      std::stringstream ss;
+      type_ref->dump(ss);
+      LLDB_LOGF(log, "[TargetReflectionContext::getTypeInfo] Getting "
+                  "type info for typeref:\n%s",
+                  ss.str().c_str());
+    }
+
+    auto type_info = m_reflection_ctx.getTypeInfo(type_ref, provider);
+    if (log && !type_info) {
+      std::stringstream ss;
+      type_ref->dump(ss);
+      LLDB_LOGF(log,
+                "[TargetReflectionContext::getTypeInfo] Could not get "
+                "type info for typeref:\n%s",
+                ss.str().c_str());
+    }
+
+    if (log && log->GetVerbose()) {
+      std::stringstream ss;
+      type_info->dump(ss);
+      log->Printf("[TargetReflectionContext::getTypeInfo] Found "
+                  "type info:\n%s",
+                  ss.str().c_str());
+    }
+    return type_info;
   }
 
   swift::reflection::MemoryReader &getReader() override {
@@ -991,6 +1020,7 @@ llvm::Optional<unsigned>
 SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
                                          ExecutionContextScope *exe_scope) {
   LLDB_SCOPED_TIMER();
+
   auto ts = type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwiftTypeRef>();
   if (!ts)
     return {};
@@ -1004,14 +1034,14 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
   const swift::reflection::TypeRef *tr = nullptr;
   auto *ti = GetSwiftRuntimeTypeInfo(type, exe_scope, &tr);
   if (!ti) {
-    LLDB_LOG(GetLog(LLDBLog::Types), "GetSwiftRuntimeTypeInfo() failed for {0}",
-             type.GetMangledTypeName());
+    LLDB_LOGF(GetLog(LLDBLog::Types), "GetSwiftRuntimeTypeInfo() failed for %s",
+              type.GetMangledTypeName().GetCString());
     return {};
   }
   // Structs and Tuples.
   if (auto *rti = llvm::dyn_cast<swift::reflection::RecordTypeInfo>(ti)) {
-    LLDB_LOG(GetLog(LLDBLog::Types), "{0}: RecordTypeInfo(num_fields={1})",
-             type.GetMangledTypeName(), rti->getNumFields());
+    LLDB_LOGF(GetLog(LLDBLog::Types), "%s: RecordTypeInfo(num_fields=%i)",
+             type.GetMangledTypeName().GetCString(), rti->getNumFields());
     switch (rti->getRecordKind()) {
     case swift::reflection::RecordKind::ExistentialMetatype:
     case swift::reflection::RecordKind::ThickFunction:
@@ -1029,14 +1059,15 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
     }
   }
   if (auto *eti = llvm::dyn_cast<swift::reflection::EnumTypeInfo>(ti)) {
-    LLDB_LOG(GetLog(LLDBLog::Types), "{0}: EnumTypeInfo(num_payload_cases={1})",
-             type.GetMangledTypeName(), eti->getNumPayloadCases());
+    LLDB_LOGF(GetLog(LLDBLog::Types), "%s: EnumTypeInfo(num_payload_cases=%i)",
+              type.GetMangledTypeName().GetCString(),
+              eti->getNumPayloadCases());
     return eti->getNumPayloadCases();
   }
   // Objects.
   if (auto *rti = llvm::dyn_cast<swift::reflection::ReferenceTypeInfo>(ti)) {
-    LLDB_LOG(GetLog(LLDBLog::Types), "{0}: ReferenceTypeInfo()",
-             type.GetMangledTypeName());
+    LLDB_LOGF(GetLog(LLDBLog::Types), "%s: ReferenceTypeInfo()",
+              type.GetMangledTypeName().GetCString());
     switch (rti->getReferenceKind()) {
     case swift::reflection::ReferenceKind::Weak:
     case swift::reflection::ReferenceKind::Unowned:
@@ -1061,8 +1092,8 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
     if (auto *rti =
             llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(cti)) {
       LLDB_LOG(GetLog(LLDBLog::Types),
-               "{0}: class RecordTypeInfo(num_fields={1})",
-               type.GetMangledTypeName(), rti->getNumFields());
+               "%s: class RecordTypeInfo(num_fields=%i)",
+               type.GetMangledTypeName().GetCString(), rti->getNumFields());
 
       // The superclass, if any, is an extra child.
       if (builder.lookupSuperclass(tr))
@@ -1073,8 +1104,8 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
     return {};
   }
   // FIXME: Implement more cases.
-  LLDB_LOG(GetLog(LLDBLog::Types), "{0}: unimplemented type info",
-            type.GetMangledTypeName());
+  LLDB_LOG(GetLog(LLDBLog::Types), "%s: unimplemented type info",
+           type.GetMangledTypeName().GetCString());
   return {};
 }
 
@@ -1824,7 +1855,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Pack(
     auto typeref_or_err =
         decodeMangledType(reflection_ctx->getBuilder(), pack_element);
     if (typeref_or_err.isError()) {
-      LLDB_LOG(log, "Couldn't get TypeRef for %s",
+      LLDB_LOGF(log, "Couldn't get TypeRef for %s",
                pack_type.GetMangledTypeName().GetCString());
       return false;
     }
@@ -2439,8 +2470,9 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
     return ts.GetTypeFromMangledTypename(mangled_name);
   }
   CompilerType bound_type =  scratch_ctx->RemangleAsType(dem, node);
-  LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types), "Bound {0} -> {1}.",
-           mangled_name, bound_type.GetMangledTypeName());
+  LLDB_LOGF(GetLog(LLDBLog::Expressions | LLDBLog::Types), "Bound %s -> %s.",
+            mangled_name.GetCString(),
+            bound_type.GetMangledTypeName().GetCString());
   return bound_type;
 }
 
@@ -3173,6 +3205,12 @@ lldb::addr_t SwiftLanguageRuntimeImpl::FixupAddress(lldb::addr_t addr,
 const swift::reflection::TypeRef *
 SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
                                      TypeSystemSwiftTypeRef *module_holder) {
+  Log *log(GetLog(LLDBLog::Types));
+  if (log && log->GetVerbose())
+    LLDB_LOGF(log, "[SwiftLanguageRuntimeImpl::GetTypeRef] Getting typeref for "
+                "type: %s\n",
+                type.GetMangledTypeName().GetCString());
+
   // Demangle the mangled name.
   swift::Demangle::Demangler dem;
   ConstString mangled_name = type.GetMangledTypeName();
@@ -3190,17 +3228,37 @@ SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
     return nullptr;
 
   auto type_ref_or_err =
-    swift::Demangle::decodeMangledType(reflection_ctx->getBuilder(), node);
-  if (type_ref_or_err.isError())
+      swift::Demangle::decodeMangledType(reflection_ctx->getBuilder(), node);
+  if (type_ref_or_err.isError()) {
+    LLDB_LOGF(log,
+              "[SwiftLanguageRuntimeImpl::GetTypeRef] Could not find typeref "
+              "for type: %s. Decode mangled type failed. Error: %s\n.",
+              type.GetMangledTypeName().GetCString(),
+              type_ref_or_err.getError()->copyErrorString());
     return nullptr;
+  }
   const swift::reflection::TypeRef *type_ref = type_ref_or_err.getType();
+  if (log && log->GetVerbose()) {
+    std::stringstream ss;
+    type_ref->dump(ss);
+    LLDB_LOGF(log, "[SwiftLanguageRuntimeImpl::GetTypeRef] Found typeref for "
+                "type: %s:\n%s",
+                type.GetMangledTypeName().GetCString(), ss.str().c_str());
+  }
   return type_ref;
 }
 
 const swift::reflection::TypeInfo *
 SwiftLanguageRuntimeImpl::GetSwiftRuntimeTypeInfo(
     CompilerType type, ExecutionContextScope *exe_scope,
     swift::reflection::TypeRef const **out_tr) {
+  Log *log(GetLog(LLDBLog::Types));
+
+  if (log && log->GetVerbose())
+    LLDB_LOGF(log, "[SwiftLanguageRuntimeImpl::GetSwiftRuntimeTypeInfo] Getting "
+                "type info for type: %s\n",
+                type.GetMangledTypeName().GetCString());
+
   auto ts = type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
   if (!ts)
     return nullptr;