[lldb] upgrade HandleFrameFormatVariable callees to llvm::Expected #144731

charles-zablit · 2025-06-18T15:44:21Z

Upgrade the callees of HandleFrameFormatVariable (GetDemangledTemplateArguments, etc), to return a llvm::Expected instead of an std::optional.

This patch also bundles the logic of validating the demangled name and information into a single reusable function to reduce code duplication.

llvmbot · 2025-06-18T15:44:54Z

@llvm/pr-subscribers-lldb

Author: Charles Zablit (charles-zablit)

Changes

Upgrade the callees of HandleFrameFormatVariable (GetDemangledTemplateArguments, etc), to return a llvm::Expected instead of an std::optional.

This patch also bundles the logic of validating the demangled name and information into a single reusable function to reduce code duplication.

Full diff: https://github.com/llvm/llvm-project/pull/144731.diff

1 Files Affected:

(modified) lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp (+110-156)

diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
index 0f18abb47591d..1810c07652a2b 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
@@ -236,199 +236,140 @@ static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
   return true;
 }
 
-static std::optional<llvm::StringRef>
-GetDemangledBasename(const SymbolContext &sc) {
+static llvm::Expected<std::pair<llvm::StringRef, DemangledNameInfo>>
+GetAndValidateInfo(const SymbolContext &sc) {
   Mangled mangled = sc.GetPossiblyInlinedFunctionName();
   if (!mangled)
-    return std::nullopt;
+    return llvm::createStringError("Function does not have a mangled name.");
 
   auto demangled_name = mangled.GetDemangledName().GetStringRef();
   if (demangled_name.empty())
-    return std::nullopt;
+    return llvm::createStringError("Function does not have a demangled name.");
 
   const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
   if (!info)
-    return std::nullopt;
+    return llvm::createStringError("Function does not have demangled info.");
 
   // Function without a basename is nonsense.
   if (!info->hasBasename())
-    return std::nullopt;
+    return llvm::createStringError("Info do not have basename range.");
 
-  return demangled_name.slice(info->BasenameRange.first,
-                              info->BasenameRange.second);
+  return std::make_pair(demangled_name, *info);
 }
 
-static std::optional<llvm::StringRef>
-GetDemangledTemplateArguments(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
+static llvm::Expected<llvm::StringRef>
+GetDemangledBasename(const SymbolContext &sc) {
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
+  return demangled_name.slice(info.BasenameRange.first,
+                              info.BasenameRange.second);
+}
 
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
+static llvm::Expected<llvm::StringRef>
+GetDemangledTemplateArguments(const SymbolContext &sc) {
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
+
+  auto [demangled_name, info] = *info_or_err;
 
-  if (info->ArgumentsRange.first < info->BasenameRange.second)
-    return std::nullopt;
+  if (info.ArgumentsRange.first < info.BasenameRange.second)
+    return llvm::createStringError("Arguments in info are invalid.");
 
-  return demangled_name.slice(info->BasenameRange.second,
-                              info->ArgumentsRange.first);
+  return demangled_name.slice(info.BasenameRange.second,
+                              info.ArgumentsRange.first);
 }
 
-static std::optional<llvm::StringRef>
+static llvm::Expected<llvm::StringRef>
 GetDemangledReturnTypeLHS(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
+  if (info.ScopeRange.first >= demangled_name.size())
+    return llvm::createStringError("Scope range is invalid.");
 
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
-
-  if (info->ScopeRange.first >= demangled_name.size())
-    return std::nullopt;
-
-  return demangled_name.substr(0, info->ScopeRange.first);
+  return demangled_name.substr(0, info.ScopeRange.first);
 }
 
-static std::optional<llvm::StringRef>
+static llvm::Expected<llvm::StringRef>
 GetDemangledFunctionQualifiers(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
-
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
+  if (info.QualifiersRange.second < info.QualifiersRange.first)
+    return llvm::createStringError("Qualifiers range is invalid.");
 
-  if (info->QualifiersRange.second < info->QualifiersRange.first)
-    return std::nullopt;
-
-  return demangled_name.slice(info->QualifiersRange.first,
-                              info->QualifiersRange.second);
+  return demangled_name.slice(info.QualifiersRange.first,
+                              info.QualifiersRange.second);
 }
 
-static std::optional<llvm::StringRef>
+static llvm::Expected<llvm::StringRef>
 GetDemangledReturnTypeRHS(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
-
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
-
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  if (info->QualifiersRange.first < info->ArgumentsRange.second)
-    return std::nullopt;
+  if (info.QualifiersRange.first < info.ArgumentsRange.second)
+    return llvm::createStringError("Qualifiers range is invalid.");
 
-  return demangled_name.slice(info->ArgumentsRange.second,
-                              info->QualifiersRange.first);
+  return demangled_name.slice(info.ArgumentsRange.second,
+                              info.QualifiersRange.first);
 }
 
-static std::optional<llvm::StringRef>
+static llvm::Expected<llvm::StringRef>
 GetDemangledScope(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
-
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
-
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  if (info->ScopeRange.second < info->ScopeRange.first)
-    return std::nullopt;
+  if (info.ScopeRange.second < info.ScopeRange.first)
+    return llvm::createStringError("Info do not have basename range.");
 
-  return demangled_name.slice(info->ScopeRange.first, info->ScopeRange.second);
+  return demangled_name.slice(info.ScopeRange.first, info.ScopeRange.second);
 }
 
 /// Handles anything printed after the FunctionEncoding ItaniumDemangle
 /// node. Most notably the DotSUffix node.
-static std::optional<llvm::StringRef>
+static llvm::Expected<llvm::StringRef>
 GetDemangledFunctionSuffix(const SymbolContext &sc) {
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return std::nullopt;
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err)
+    return info_or_err.takeError();
 
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return std::nullopt;
+  auto [demangled_name, info] = *info_or_err;
 
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return std::nullopt;
-
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
-    return std::nullopt;
-
-  return demangled_name.slice(info->SuffixRange.first,
-                              info->SuffixRange.second);
+  return demangled_name.slice(info.SuffixRange.first, info.SuffixRange.second);
 }
 
 static bool PrintDemangledArgumentList(Stream &s, const SymbolContext &sc) {
   assert(sc.symbol);
 
-  Mangled mangled = sc.GetPossiblyInlinedFunctionName();
-  if (!mangled)
-    return false;
-
-  auto demangled_name = mangled.GetDemangledName().GetStringRef();
-  if (demangled_name.empty())
-    return false;
-
-  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
-  if (!info)
-    return false;
-
-  // Function without a basename is nonsense.
-  if (!info->hasBasename())
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err) {
+    info_or_err.takeError();
     return false;
+  }
+  auto [demangled_name, info] = *info_or_err;
 
-  if (info->ArgumentsRange.second < info->ArgumentsRange.first)
+  if (info.ArgumentsRange.second < info.ArgumentsRange.first)
     return false;
 
-  s << demangled_name.slice(info->ArgumentsRange.first,
-                            info->ArgumentsRange.second);
+  s << demangled_name.slice(info.ArgumentsRange.first,
+                            info.ArgumentsRange.second);
 
   return true;
 }
@@ -1954,32 +1895,37 @@ bool CPlusPlusLanguage::HandleFrameFormatVariable(
     FormatEntity::Entry::Type type, Stream &s) {
   switch (type) {
   case FormatEntity::Entry::Type::FunctionScope: {
-    std::optional<llvm::StringRef> scope = GetDemangledScope(sc);
-    if (!scope)
+    auto scope_or_err = GetDemangledScope(sc);
+    if (!scope_or_err) {
+      llvm::consumeError(scope_or_err.takeError());
       return false;
+    }
 
-    s << *scope;
+    s << *scope_or_err;
 
     return true;
   }
 
   case FormatEntity::Entry::Type::FunctionBasename: {
-    std::optional<llvm::StringRef> name = GetDemangledBasename(sc);
-    if (!name)
+    auto name_or_err = GetDemangledBasename(sc);
+    if (!name_or_err) {
+      llvm::consumeError(name_or_err.takeError());
       return false;
+    }
 
-    s << *name;
+    s << *name_or_err;
 
     return true;
   }
 
   case FormatEntity::Entry::Type::FunctionTemplateArguments: {
-    std::optional<llvm::StringRef> template_args =
-        GetDemangledTemplateArguments(sc);
-    if (!template_args)
+    auto template_args_or_err = GetDemangledTemplateArguments(sc);
+    if (!template_args_or_err) {
+      llvm::consumeError(template_args_or_err.takeError());
       return false;
+    }
 
-    s << *template_args;
+    s << *template_args_or_err;
 
     return true;
   }
@@ -2008,38 +1954,46 @@ bool CPlusPlusLanguage::HandleFrameFormatVariable(
     return true;
   }
   case FormatEntity::Entry::Type::FunctionReturnRight: {
-    std::optional<llvm::StringRef> return_rhs = GetDemangledReturnTypeRHS(sc);
-    if (!return_rhs)
+    auto return_rhs_or_err = GetDemangledReturnTypeRHS(sc);
+    if (!return_rhs_or_err) {
+      llvm::consumeError(return_rhs_or_err.takeError());
       return false;
+    }
 
-    s << *return_rhs;
+    s << *return_rhs_or_err;
 
     return true;
   }
   case FormatEntity::Entry::Type::FunctionReturnLeft: {
-    std::optional<llvm::StringRef> return_lhs = GetDemangledReturnTypeLHS(sc);
-    if (!return_lhs)
+    auto return_lhs_or_err = GetDemangledReturnTypeLHS(sc);
+    if (!return_lhs_or_err) {
+      llvm::consumeError(return_lhs_or_err.takeError());
       return false;
+    }
 
-    s << *return_lhs;
+    s << *return_lhs_or_err;
 
     return true;
   }
   case FormatEntity::Entry::Type::FunctionQualifiers: {
-    std::optional<llvm::StringRef> quals = GetDemangledFunctionQualifiers(sc);
-    if (!quals)
+    auto quals_or_err = GetDemangledFunctionQualifiers(sc);
+    if (!quals_or_err) {
+      llvm::consumeError(quals_or_err.takeError());
       return false;
+    }
 
-    s << *quals;
+    s << *quals_or_err;
 
     return true;
   }
   case FormatEntity::Entry::Type::FunctionSuffix: {
-    std::optional<llvm::StringRef> suffix = GetDemangledFunctionSuffix(sc);
-    if (!suffix)
+    auto suffix_or_err = GetDemangledFunctionSuffix(sc);
+    if (!suffix_or_err) {
+      llvm::consumeError(suffix_or_err.takeError());
       return false;
+    }
 
-    s << *suffix;
+    s << *suffix_or_err;
 
     return true;
   }

Michael137 · 2025-06-18T16:53:31Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

-  if (!info->hasBasename())
+  auto info_or_err = GetAndValidateInfo(sc);
+  if (!info_or_err) {
+    llvm::consumeError(info_or_err.takeError());


Can we log here instead of consuming the error?

Something like:

Suggested change

llvm::consumeError(info_or_err.takeError());

LLDB_LOG_ERROR(GetLog(LLDBLog::Language), info_or_err.takeError(), "Failed to retrieve demangled info: {0}"

Might need to downgrade it to LLDB_LOG_ERRORV if we find that this is a common/unimportant error path

Same applies to all the other places where we consumeError

Fixed, thanks! LLDB_LOG_ERROR seems to be reasonable for now, I did not encounter an error message while testing on a small C++ program.

Michael137

Seems reasonable, modulo the logging comment

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

Michael137 · 2025-06-19T09:42:58Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp


  auto demangled_name = mangled.GetDemangledName().GetStringRef();
  if (demangled_name.empty())
-    return std::nullopt;
+    return llvm::createStringError("Function does not have a demangled name.");


Suggested change

return llvm::createStringError("Function does not have a demangled name.");

return llvm::createStringError("Function '%s' does not have a demangled name.", mangled.GetMangledName().AsCString(""));

Added better messages for all the createStringError.

Michael137 · 2025-06-19T09:43:47Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp


  const std::optional<DemangledNameInfo> &info = mangled.GetDemangledInfo();
  if (!info)
-    return std::nullopt;
+    return llvm::createStringError("Function does not have demangled info.");


Suggested change

return llvm::createStringError("Function does not have demangled info.");

return llvm::createStringError("Function '%s' does not have demangled info.", demangled_name.data());

Michael137 · 2025-06-19T09:44:11Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp


  // Function without a basename is nonsense.
  if (!info->hasBasename())
-    return std::nullopt;
+    return llvm::createStringError("Info do not have basename range.");


Suggested change

return llvm::createStringError("Info do not have basename range.");

return llvm::createStringError("DemangledInfo for '%s' do not have basename range.", demangled_name.data());

Michael137 · 2025-06-19T09:44:46Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

-  if (!info)
-    return std::nullopt;
+  if (info.ScopeRange.first >= demangled_name.size())
+    return llvm::createStringError("Scope range is invalid.");


Suggested change

return llvm::createStringError("Scope range is invalid.");

return llvm::createStringError("Scope range for '%s' is invalid.", demangled_name.data());

Can you similarly include the demangled_name in the error message elsewhere too?

Michael137 · 2025-06-19T09:46:55Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

+    auto name_or_err = GetDemangledBasename(sc);
+    if (!name_or_err) {
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Language), name_or_err.takeError(),
+                     "Failed to retrieve basename: {0}");


Suggested change

"Failed to retrieve basename: {0}");

"Failed to handle ${function.basename} frame-format variable: {0}");

And do this for the other messages in this switch too?

Added better messages for all the LLDB_LOG_ERROR.

charles-zablit · 2025-06-19T11:29:27Z

I think we should wait before the following PR gets merged before merging, in order to use the new has methods.

[lldb] add has methods to all DemangledNameInfo attributes #144549

…cted

charles-zablit · 2025-06-19T14:49:08Z

I think we should wait before the following PR gets merged before merging, in order to use the new has methods.

Done ✅

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

Michael137

Just left a couple follow-up comments. Otherwise LGTM!

Michael137 · 2025-06-20T08:39:17Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

+    if (!quals_or_err) {
+      LLDB_LOG_ERROR(
+          GetLog(LLDBLog::Language), quals_or_err.takeError(),
+          "Failed to handle ${function.qualifiers} frame-format variable: {0}");


Apologies, I think you need to escape the { here. Since that's the syntax for specifying the format index. I think {{ is the way to do that

No problem, thanks!

github-actions · 2025-06-20T09:19:24Z

✅ With the latest revision this PR passed the C/C++ code formatter.

Michael137 · 2025-06-20T10:05:40Z

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

-  if (!info->hasBasename())
-    return std::nullopt;
+  if (!info.hasQualifiers())
+    return llvm::createStringError("Qualifiers range for '%s' is invalid.",


Oh, not having qualifiers on a demangled name doesn't necessarily mean this is fatal. This explains the latest linux failures. Some methods just don't have qualifiers. I guess we need to return "" in that case. Should hasQualifiers also accept cases where QualifiersRange.start == QualifiersRange.end? Which just means they don't exist, but didn't fail to parse. I'm also happy to just remove this check. I think that's why i used to only check for hasBasename.

We could add another method called areQualifiersEmpty (or better name) which checks if QualifiersRange.start == QualifiersRange.end. The check would look like

if(!hasQualifiers() && !areQualifiersEmpty()) return createStringError(...); return demangled_name.slice(...);

This way we keep the semantic meaning of hasQualifiers and we can still surface parsing errors, which we would not be able to do if we remove the check.

I ended up adding a isXEmpty() method for each range which checks if xRange.first == xRange.second. This fixes the test.

Michael137 · 2025-06-20T18:16:18Z

lldb/include/lldb/Core/DemangledNameInfo.h

@@ -74,24 +74,48 @@ struct DemangledNameInfo {
    return BasenameRange.second > BasenameRange.first;
  }

+  /// Returns \c true if `BasenameRange` is empty.
+  bool isBasenameEmpty() const {
+    return BasenameRange.first == BasenameRange.second;


Hmm I think I'd prefer having only a single API that tells us "do we have a valid entity or not". E.g., hasValidQualifiers/hasValidBasename/etc. Is there a reason we can't just modify the existing hasXXX helpers to be Range.second >= Range.first? If we are going to call !hasXXX && !isEmpty then might as well fold them into a single API.

But if there's reasons we can't do that, this seems fine too

I agree that since we are calling !hasX && !isEmpty everywhere, me might just as well squash them. When doing so, the only problem I have noticed is that some tests break, such as when demangling Zinvalid which technically has no basename, but with this new implementation hasBasename returns true.

Overall, I still think it's best to collapse everything into one method like you suggested 👍

Thanks for adjusting. Mostly looks good now

Though I don't think hasBasename should allow for start == end. That's the one range that all DemangledInfo objects need to have to be considered valid. Could we keep that as end > start? I don't think that should break anything. Probably worth adding a comment there why it's not >=

Switched to > instead of >= for hasBasename. This "fixed" the tests that I originally broke 👍

This reverts commit 602eaca.

…lvm#144731) Upgrade the callees of `HandleFrameFormatVariable` (`GetDemangledTemplateArguments`, etc), to return a `llvm::Expected` instead of an `std::optional`. This patch also bundles the logic of validating the demangled name and information into a single reusable function to reduce code duplication.

charles-zablit requested a review from JDevlieghere as a code owner June 18, 2025 15:44

llvmbot added the lldb label Jun 18, 2025

charles-zablit mentioned this pull request Jun 18, 2025

[Syntax Highlighting] Add name and parameters syntax highlighting in Swift backtraces swiftlang/llvm-project#10710

Open

Michael137 reviewed Jun 18, 2025

View reviewed changes

Michael137 reviewed Jun 19, 2025

View reviewed changes

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp Outdated Show resolved Hide resolved

Michael137 reviewed Jun 19, 2025

View reviewed changes

charles-zablit added 5 commits June 19, 2025 14:28

[lldb] upgrade HandleFrameFormatVariable callees to llvm::Expected

3c9a3e5

fixup! [lldb] upgrade HandleFrameFormatVariable callees to llvm::Expe…

9000c4d

…cted

log the error instead of just consuming it

b0e4f74

improve error messages

68d8d5a

switch to has methods

6d8e8c0

charles-zablit force-pushed the charles-zablit/lldb/use-llvmExpected branch from 1af4c9e to 6d8e8c0 Compare June 19, 2025 13:54

Michael137 reviewed Jun 19, 2025

View reviewed changes

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp Show resolved Hide resolved

Michael137 reviewed Jun 19, 2025

View reviewed changes

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp Outdated Show resolved Hide resolved

Michael137 reviewed Jun 19, 2025

View reviewed changes

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp Show resolved Hide resolved

Michael137 approved these changes Jun 19, 2025

View reviewed changes

charles-zablit added 2 commits June 19, 2025 17:06

remove comment

34c1b1d

add hasSuffix check

abfa266

Michael137 reviewed Jun 20, 2025

View reviewed changes

escape format variables in log message

1bf92c9

fixup! escape format variables in log message

bc82236

Michael137 reviewed Jun 20, 2025

View reviewed changes

fix failing test

602eaca

Michael137 reviewed Jun 20, 2025

View reviewed changes

charles-zablit added 3 commits June 23, 2025 12:20

Revert "fix failing test"

a4f4e51

This reverts commit 602eaca.

relax the hasX methods in DemangledNameInfo

13269f5

hasBasename should not allow empty function names

54261ab

Michael137 approved these changes Jun 23, 2025

View reviewed changes

charles-zablit merged commit a0329ea into llvm:main Jun 23, 2025
7 checks passed

charles-zablit mentioned this pull request Jun 24, 2025

🍒 [lldb] upgrade HandleFrameFormatVariable callees to llvm::Expected swiftlang/llvm-project#10888

Merged

	llvm::consumeError(info_or_err.takeError());
	LLDB_LOG_ERROR(GetLog(LLDBLog::Language), info_or_err.takeError(), "Failed to retrieve demangled info: {0}"

	return llvm::createStringError("Function does not have a demangled name.");
	return llvm::createStringError("Function '%s' does not have a demangled name.", mangled.GetMangledName().AsCString(""));

	return llvm::createStringError("Info do not have basename range.");
	return llvm::createStringError("DemangledInfo for '%s' do not have basename range.", demangled_name.data());

	return llvm::createStringError("Scope range is invalid.");
	return llvm::createStringError("Scope range for '%s' is invalid.", demangled_name.data());

	"Failed to retrieve basename: {0}");
	"Failed to handle ${function.basename} frame-format variable: {0}");

[lldb] upgrade HandleFrameFormatVariable callees to llvm::Expected #144731

[lldb] upgrade HandleFrameFormatVariable callees to llvm::Expected #144731

Uh oh!

Conversation

charles-zablit commented Jun 18, 2025

Uh oh!

llvmbot commented Jun 18, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Michael137 left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Michael137 Jun 19, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

charles-zablit commented Jun 19, 2025

Uh oh!

charles-zablit commented Jun 19, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Michael137 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

github-actions bot commented Jun 20, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Michael137 Jun 23, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Michael137 Jun 19, 2025 •

edited

Loading

github-actions bot commented Jun 20, 2025 •

edited

Loading

Michael137 Jun 23, 2025 •

edited

Loading